Medusa Coverage Report

Files

Total Lines

4662

Coverage

63.5%

630 / 992 lines

Actions

55.6% lib/openzeppelin-contracts/contracts/access/Ownable.sol

Lines covered: 5 / 9 (55.6%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


0.0% lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)

pragma solidity >=0.6.2;

import {IERC20} from "./IERC20.sol";
import {IERC165} from "./IERC165.sol";

/**
 * @title IERC1363
 * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
 *
 * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
 * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
 */
interface IERC1363 is IERC20, IERC165 {
    /*
     * Note: the ERC-165 identifier for this interface is 0xb0202a11.
     * 0xb0202a11 ===
     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
     */

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @param data Additional data with no specified format, sent in call to `spender`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}


0.0% lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)

pragma solidity >=0.4.16;

import {IERC165} from "../utils/introspection/IERC165.sol";


0.0% lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)

pragma solidity >=0.4.16;

import {IERC20} from "../token/ERC20/IERC20.sol";


0.0% lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.5.0) (interfaces/draft-IERC6093.sol)

pragma solidity >=0.8.4;

/**
 * @dev Standard ERC-20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC-721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC-1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}


100.0% lib/openzeppelin-contracts/contracts/mocks/token/ERC20Mock.sol

Lines covered: 1 / 1 (100.0%)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import {ERC20} from "../../token/ERC20/ERC20.sol";

contract ERC20Mock is ERC20 {
    constructor() ERC20("ERC20Mock", "E20M") {}

    function mint(address account, uint256 amount) external {
        _mint(account, amount);
    }

    function burn(address account, uint256 amount) external {
        _burn(account, amount);
    }
}


56.0% lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol

Lines covered: 14 / 25 (56.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.5.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC-20
 * applications.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

    mapping(address account => mapping(address spender => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * Both values are immutable: they can only be set once during construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /// @inheritdoc IERC20
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    /// @inheritdoc IERC20
    function balanceOf(address account) public view virtual returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /// @inheritdoc IERC20
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Skips emitting an {Approval} event indicating an allowance update. This is not
     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner`'s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation sets the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the `transferFrom` operation can force the flag to
     * true using the following override:
     *
     * ```solidity
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner`'s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance < type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}


0.0% lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)

pragma solidity >=0.4.16;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}


0.0% lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity >=0.6.2;

import {IERC20} from "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC-20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}


75.0% lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol

Lines covered: 6 / 8 (75.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.5.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC1363} from "../../../interfaces/IERC1363.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC-20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    /**
     * @dev An operation with an ERC-20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        if (!_safeTransfer(token, to, value, true)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        if (!_safeTransferFrom(token, from, to, value, true)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {
        return _safeTransfer(token, to, value, false);
    }

    /**
     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {
        return _safeTransferFrom(token, from, to, value, false);
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     *
     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
     * only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
     * set here.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        if (!_safeApprove(token, spender, value, false)) {
            if (!_safeApprove(token, spender, 0, true)) revert SafeERC20FailedOperation(address(token));
            if (!_safeApprove(token, spender, value, true)) revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            safeTransfer(token, to, value);
        } else if (!token.transferAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
     * has no code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferFromAndCallRelaxed(
        IERC1363 token,
        address from,
        address to,
        uint256 value,
        bytes memory data
    ) internal {
        if (to.code.length == 0) {
            safeTransferFrom(token, from, to, value);
        } else if (!token.transferFromAndCall(from, to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
     * Oppositely, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
     * once without retrying, and relies on the returned value to be true.
     *
     * Reverts if the returned value is other than `true`.
     */
    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            forceApprove(token, to, value);
        } else if (!token.approveAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity `token.transfer(to, value)` call, relaxing the requirement on the return value: the
     * return value is optional (but if data is returned, it must not be false).
     *
     * @param token The token targeted by the call.
     * @param to The recipient of the tokens
     * @param value The amount of token to transfer
     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.
     */
    function _safeTransfer(IERC20 token, address to, uint256 value, bool bubble) private returns (bool success) {
        bytes4 selector = IERC20.transfer.selector;

        assembly ("memory-safe") {
            let fmp := mload(0x40)
            mstore(0x00, selector)
            mstore(0x04, and(to, shr(96, not(0))))
            mstore(0x24, value)
            success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)
            // if call success and return is true, all is good.
            // otherwise (not success or return is not true), we need to perform further checks
            if iszero(and(success, eq(mload(0x00), 1))) {
                // if the call was a failure and bubble is enabled, bubble the error
                if and(iszero(success), bubble) {
                    returndatacopy(fmp, 0x00, returndatasize())
                    revert(fmp, returndatasize())
                }
                // if the return value is not true, then the call is only successful if:
                // - the token address has code
                // - the returndata is empty
                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))
            }
            mstore(0x40, fmp)
        }
    }

    /**
     * @dev Imitates a Solidity `token.transferFrom(from, to, value)` call, relaxing the requirement on the return
     * value: the return value is optional (but if data is returned, it must not be false).
     *
     * @param token The token targeted by the call.
     * @param from The sender of the tokens
     * @param to The recipient of the tokens
     * @param value The amount of token to transfer
     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.
     */
    function _safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value,
        bool bubble
    ) private returns (bool success) {
        bytes4 selector = IERC20.transferFrom.selector;

        assembly ("memory-safe") {
            let fmp := mload(0x40)
            mstore(0x00, selector)
            mstore(0x04, and(from, shr(96, not(0))))
            mstore(0x24, and(to, shr(96, not(0))))
            mstore(0x44, value)
            success := call(gas(), token, 0, 0x00, 0x64, 0x00, 0x20)
            // if call success and return is true, all is good.
            // otherwise (not success or return is not true), we need to perform further checks
            if iszero(and(success, eq(mload(0x00), 1))) {
                // if the call was a failure and bubble is enabled, bubble the error
                if and(iszero(success), bubble) {
                    returndatacopy(fmp, 0x00, returndatasize())
                    revert(fmp, returndatasize())
                }
                // if the return value is not true, then the call is only successful if:
                // - the token address has code
                // - the returndata is empty
                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))
            }
            mstore(0x40, fmp)
            mstore(0x60, 0)
        }
    }

    /**
     * @dev Imitates a Solidity `token.approve(spender, value)` call, relaxing the requirement on the return value:
     * the return value is optional (but if data is returned, it must not be false).
     *
     * @param token The token targeted by the call.
     * @param spender The spender of the tokens
     * @param value The amount of token to transfer
     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.
     */
    function _safeApprove(IERC20 token, address spender, uint256 value, bool bubble) private returns (bool success) {
        bytes4 selector = IERC20.approve.selector;

        assembly ("memory-safe") {
            let fmp := mload(0x40)
            mstore(0x00, selector)
            mstore(0x04, and(spender, shr(96, not(0))))
            mstore(0x24, value)
            success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)
            // if call success and return is true, all is good.
            // otherwise (not success or return is not true), we need to perform further checks
            if iszero(and(success, eq(mload(0x00), 1))) {
                // if the call was a failure and bubble is enabled, bubble the error
                if and(iszero(success), bubble) {
                    returndatacopy(fmp, 0x00, returndatasize())
                    revert(fmp, returndatasize())
                }
                // if the return value is not true, then the call is only successful if:
                // - the token address has code
                // - the returndata is empty
                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))
            }
            mstore(0x40, fmp)
        }
    }
}


100.0% lib/openzeppelin-contracts/contracts/utils/Context.sol

Lines covered: 1 / 1 (100.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}


83.3% lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol

Lines covered: 5 / 6 (83.3%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.5.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

import {StorageSlot} from "./StorageSlot.sol";

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 *
 * IMPORTANT: Deprecated. This storage-based reentrancy guard will be removed and replaced
 * by the {ReentrancyGuardTransient} variant in v6.0.
 *
 * @custom:stateless
 */
abstract contract ReentrancyGuard {
    using StorageSlot for bytes32;

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ReentrancyGuard")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant REENTRANCY_GUARD_STORAGE =
        0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;

    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _reentrancyGuardStorageSlot().getUint256Slot().value = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    /**
     * @dev A `view` only version of {nonReentrant}. Use to block view functions
     * from being called, preventing reading from inconsistent contract state.
     *
     * CAUTION: This is a "view" modifier and does not change the reentrancy
     * status. Use it only on view functions. For payable or non-payable functions,
     * use the standard {nonReentrant} modifier instead.
     */
    modifier nonReentrantView() {
        _nonReentrantBeforeView();
        _;
    }

    function _nonReentrantBeforeView() private view {
        if (_reentrancyGuardEntered()) {
            revert ReentrancyGuardReentrantCall();
        }
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        _nonReentrantBeforeView();

        // Any calls to nonReentrant after this point will fail
        _reentrancyGuardStorageSlot().getUint256Slot().value = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _reentrancyGuardStorageSlot().getUint256Slot().value = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _reentrancyGuardStorageSlot().getUint256Slot().value == ENTERED;
    }

    function _reentrancyGuardStorageSlot() internal pure virtual returns (bytes32) {
        return REENTRANCY_GUARD_STORAGE;
    }
}


100.0% lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol

Lines covered: 1 / 1 (100.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.20;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC-1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(newImplementation.code.length > 0);
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * TIP: Consider using this library along with {SlotDerivation}.
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct Int256Slot {
        int256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Int256Slot` with member `value` located at `slot`.
     */
    function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        assembly ("memory-safe") {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns a `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        assembly ("memory-safe") {
            r.slot := store.slot
        }
    }
}


0.0% lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)

pragma solidity >=0.4.16;

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}


58.2% src/CreditPolicy.sol

Lines covered: 57 / 98 (58.2%)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import {ICreditPolicy} from "./interfaces/ICreditPolicy.sol";


/**
 * @title CreditPolicy
 * @notice Immutable-by-version credit constitution for private credit funds
 */
contract CreditPolicy is ICreditPolicy {
    /*//////////////////////////////////////////////////////////////
                                ERRORS
    //////////////////////////////////////////////////////////////*/
    error CreditPolicy__Unauthorized();
    error CreditPolicy__PolicyFrozen(uint256 version);
    error CreditPolicy__InvalidVersion();
    error CreditPolicy__PolicyVersionExists(uint256 version);
    error CreditPolicy__InvalidAdmin();
    error CreditPolicy__PolicyNotEditable(uint256 version);
    error CreditPolicy__IncompletePolicy(uint256 version);
    error CreditPolicy__InvalidIndustryHash();
    error CreditPolicy__PolicyNotActive(uint256 version);
    error CreditPolicy__InvalidTierCount(uint256 count);
    /*//////////////////////////////////////////////////////////////
                                MODIFIERS
    //////////////////////////////////////////////////////////////*/
    modifier onlyAdmin() {
        _onlyAdmin();
        _;
    }

    function _onlyAdmin() internal view {
        if (msg.sender != policyAdmin) revert CreditPolicy__Unauthorized();
    }

    modifier policyEditable(uint256 version) {
        _policyEditable(version);
        _;
    }

    function _policyEditable(uint256 version) internal view {
        if (policyFrozen[version] || !policyActive[version])
            revert CreditPolicy__PolicyNotEditable(version);
    }

    modifier policyExists(uint256 version) {
        _policyExists(version);
        _;
    }

    function _policyExists(uint256 version) internal view {
        if (!policyCreated[version]) revert CreditPolicy__InvalidVersion();
    }

    /*//////////////////////////////////////////////////////////////
                                CORE ROLES
    //////////////////////////////////////////////////////////////*/
    address public policyAdmin;
    uint8 internal maxTiers;

    /*//////////////////////////////////////////////////////////////
                            POLICY LIFECYCLE
    //////////////////////////////////////////////////////////////*/
    mapping(uint256 => bool) public policyCreated;
    mapping(uint256 => bool) public policyFrozen;
    mapping(uint256 => bool) public policyActive;
    mapping(uint256 => uint256) public lastUpdated;

    /*//////////////////////////////////////////////////////////////
                        ELIGIBILITY (PRE-LOAN)
    //////////////////////////////////////////////////////////////*/
    struct EligibilityCriteria {
        uint256 minAnnualRevenue;
        uint256 minEBITDA;
        uint256 minTangibleNetWorth;
        uint256 minBusinessAgeDays;
        uint256 maxDefaultsLast36Months;
        bool bankruptcyExcluded;
    }

    mapping(uint256 => EligibilityCriteria) public eligibility;

    /*//////////////////////////////////////////////////////////////
                        FINANCIAL RATIOS (UNDERWRITING)
    //////////////////////////////////////////////////////////////*/
    struct FinancialRatios {
        uint256 maxTotalDebtToEBITDA;
        uint256 minInterestCoverageRatio;
        uint256 minCurrentRatio;
        uint256 minEBITDAMarginBps;
    }

    mapping(uint256 => FinancialRatios) public ratios;

    /*//////////////////////////////////////////////////////////////
                        LOAN TIERS (PRICING REFERENCE)
    //////////////////////////////////////////////////////////////*/
    struct LoanTier {
        string name;
        uint256 minRevenue;
        uint256 maxRevenue;
        uint256 minEBITDA;
        uint256 maxDebtToEBITDA;
        uint256 maxLoanToEBITDA;
        uint256 interestRateBps;
        uint256 originationFeeBps;
        uint256 termDays;
        bool active;
    }

    mapping(uint256 => mapping(uint8 => LoanTier)) public loanTiers;
    mapping(uint256 => uint8) public totalTiers;
    mapping(uint256 => mapping(uint8 => bool)) public tierExists;

    /*//////////////////////////////////////////////////////////////
                        CONCENTRATION LIMITS
    //////////////////////////////////////////////////////////////*/
    struct ConcentrationLimits {
        uint256 maxSingleBorrowerBps;
        uint256 maxIndustryConcentrationBps;
    }

    mapping(uint256 => ConcentrationLimits) public concentration;

    /*//////////////////////////////////////////////////////////////
                        INDUSTRY EXCLUSIONS
    //////////////////////////////////////////////////////////////*/
    mapping(uint256 => mapping(bytes32 => bool)) public excludedIndustries;

    /*//////////////////////////////////////////////////////////////
                        ATTESTATION REQUIREMENTS
    //////////////////////////////////////////////////////////////*/
    struct AttestationRequirements {
        uint256 maxAttestationAgeDays;
        uint256 reAttestationFrequencyDays;
        bool requiresCPAAttestation;
    }

    mapping(uint256 => AttestationRequirements) public attestation;

    /*//////////////////////////////////////////////////////////////
                        MAINTENANCE COVENANTS
    //////////////////////////////////////////////////////////////*/
    struct MaintenanceCovenants {
        uint256 maxLeverageRatio;
        uint256 minCoverageRatio;
        uint256 minLiquidityAmount;
        bool allowsDividends;
        uint256 reportingFrequencyDays;
    }

    mapping(uint256 => MaintenanceCovenants) public covenants;

    /*//////////////////////////////////////////////////////////////
                        DOCUMENT ANCHORING
    //////////////////////////////////////////////////////////////*/
    mapping(uint256 => bytes32) public policyDocumentHash;
    mapping(uint256 => string) public policyDocumentURI;

    mapping(uint256 => bool) public eligibilitySet;
    mapping(uint256 => bool) public ratiosSet;
    mapping(uint256 => bool) public concentrationSet;
    mapping(uint256 => bool) public attestationSet;
    mapping(uint256 => bool) public covenantsSet;
    mapping(uint256 => bool) public hasAtLeastOneTier;

    /*//////////////////////////////////////////////////////////////
                                EVENTS
    //////////////////////////////////////////////////////////////*/
    event PolicyCreated(uint256 version, uint256 timestamp);
    event PolicyFrozen(uint256 version, uint256 timestamp);
    event PolicyEligibilityUpdated(uint256 version, uint256 timestamp);
    event PolicyRatiosUpdated(uint256 version, uint256 timestamp);
    event PolicyConcentrationUpdated(uint256 version, uint256 timestamp);
    event PolicyAttestationUpdated(uint256 version, uint256 timestamp);
    event PolicyCovenantsUpdated(uint256 version, uint256 timestamp);
    event LoanTierUpdated(uint256 version, uint8 tierId, uint256 timestamp);
    event IndustryExcluded(
        uint256 version,
        bytes32 industry,
        uint256 timestamp
    );
    event MaxTiersChanged(uint8 maxTiers);
    event IndustryIncluded(
        uint256 version,
        bytes32 industry,
        uint256 timestamp
    );

    event PolicyAdminChanged(address newAdmin);

    event PolicyDocumentSet(
        uint256 version,
        bytes32 hash,
        string uri,
        uint256 timestamp
    );
    event PolicyDeactivated(uint256 version, uint256 timestamp);

    /*//////////////////////////////////////////////////////////////
                                CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/
    constructor() {
        policyAdmin = msg.sender;
    }

    /*//////////////////////////////////////////////////////////////
                        POLICY CREATION
    //////////////////////////////////////////////////////////////*/

    function createPolicy(uint256 version) external onlyAdmin {
        if (version == 0) {
            revert CreditPolicy__InvalidVersion();
        }
        if (policyCreated[version]) {
            revert CreditPolicy__PolicyVersionExists(version);
        }

        policyCreated[version] = true;
        policyActive[version] = true;
        lastUpdated[version] = block.timestamp;
        emit PolicyCreated(version, block.timestamp);
    }

    function freezePolicy(
        uint256 version
    ) external onlyAdmin policyExists(version) {
        if (policyFrozen[version]) {
            revert CreditPolicy__PolicyFrozen(version);
        }
        if (policyActive[version] == false) {
            revert CreditPolicy__PolicyNotActive(version);
        }
        if (
            !eligibilitySet[version] ||
            !ratiosSet[version] ||
            !concentrationSet[version] ||
            !attestationSet[version] ||
            !covenantsSet[version] ||
            !hasAtLeastOneTier[version]
        ) {
            revert CreditPolicy__IncompletePolicy(version);
        }
        if (policyDocumentHash[version] == bytes32(0)) {
            revert CreditPolicy__IncompletePolicy(version);
        }

        policyFrozen[version] = true;
        lastUpdated[version] = block.timestamp;
        emit PolicyFrozen(version, block.timestamp);
    }

    function deActivatePolicy(
        uint256 version
    ) external onlyAdmin policyExists(version) {
        policyActive[version] = false;
        lastUpdated[version] = block.timestamp;
        emit PolicyDeactivated(version, block.timestamp);
    }

    /*//////////////////////////////////////////////////////////////
                        ELIGIBILITY UPDATE
    //////////////////////////////////////////////////////////////*/
    function updateEligibility(
        uint256 version,
        EligibilityCriteria calldata data
    ) external onlyAdmin policyExists(version) policyEditable(version) {
        eligibility[version] = data;
        lastUpdated[version] = block.timestamp;
        eligibilitySet[version] = true;
        emit PolicyEligibilityUpdated(version, block.timestamp);
    }

    /*//////////////////////////////////////////////////////////////
                        RATIOS UPDATE
    //////////////////////////////////////////////////////////////*/
    function updateRatios(
        uint256 version,
        FinancialRatios calldata data
    ) external onlyAdmin policyExists(version) policyEditable(version) {
        ratios[version] = data;
        lastUpdated[version] = block.timestamp;
        ratiosSet[version] = true;
        emit PolicyRatiosUpdated(version, block.timestamp);
    }

    /*//////////////////////////////////////////////////////////////
                        CONCENTRATION UPDATE
    //////////////////////////////////////////////////////////////*/
    function updateConcentration(
        uint256 version,
        ConcentrationLimits calldata data
    ) external onlyAdmin policyExists(version) policyEditable(version) {
        concentration[version] = data;
        lastUpdated[version] = block.timestamp;
        concentrationSet[version] = true;
        emit PolicyConcentrationUpdated(version, block.timestamp);
    }

    /*//////////////////////////////////////////////////////////////
                        ATTESTATION UPDATE
    //////////////////////////////////////////////////////////////*/
    function updateAttestation(
        uint256 version,
        AttestationRequirements calldata data
    ) external onlyAdmin policyExists(version) policyEditable(version) {
        attestation[version] = data;
        lastUpdated[version] = block.timestamp;
        attestationSet[version] = true;
        emit PolicyAttestationUpdated(version, block.timestamp);
    }

    /*//////////////////////////////////////////////////////////////
                        COVENANT UPDATE
    //////////////////////////////////////////////////////////////*/
    function updateCovenants(
        uint256 version,
        MaintenanceCovenants calldata data
    ) external onlyAdmin policyExists(version) policyEditable(version) {
        covenants[version] = data;
        lastUpdated[version] = block.timestamp;
        covenantsSet[version] = true;
        emit PolicyCovenantsUpdated(version, block.timestamp);
    }

    /*//////////////////////////////////////////////////////////////
                        LOAN TIERS
    //////////////////////////////////////////////////////////////*/
    function setLoanTier(
        uint256 version,
        uint8 tierId,
        LoanTier calldata tier
    ) external onlyAdmin policyExists(version) policyEditable(version) {
        if (tierId >= maxTiers) {
            revert CreditPolicy__InvalidTierCount(tierId);
        }
        loanTiers[version][tierId] = tier;
        tierExists[version][tierId] = true;
        if (tierId >= totalTiers[version]) {
            totalTiers[version] = tierId + 1;
        }
        hasAtLeastOneTier[version] = true;
        lastUpdated[version] = block.timestamp;
        emit LoanTierUpdated(version, tierId, block.timestamp);
    }

    /*//////////////////////////////////////////////////////////////
                        INDUSTRY CONTROLS
    //////////////////////////////////////////////////////////////*/
    function excludeIndustry(
        uint256 version,
        bytes32 industry
    ) external onlyAdmin policyExists(version) policyEditable(version) {
        if (industry == bytes32(0)) {
            revert CreditPolicy__InvalidIndustryHash();
        }
        excludedIndustries[version][industry] = true;
        lastUpdated[version] = block.timestamp;
        emit IndustryExcluded(version, industry, block.timestamp);
    }

    function includeIndustry(
        uint256 version,
        bytes32 industry
    ) external onlyAdmin policyExists(version) policyEditable(version) {
        if (industry == bytes32(0)) {
            revert CreditPolicy__InvalidIndustryHash();
        }
        excludedIndustries[version][industry] = false;
        lastUpdated[version] = block.timestamp;
        emit IndustryIncluded(version, industry, block.timestamp);
    }

    /*//////////////////////////////////////////////////////////////
                        DOCUMENT UPDATE
    //////////////////////////////////////////////////////////////*/
    function setPolicyDocument(
        uint256 version,
        bytes32 hash,
        string calldata uri
    ) external onlyAdmin policyExists(version) policyEditable(version) {
        policyDocumentHash[version] = hash;
        policyDocumentURI[version] = uri;
        lastUpdated[version] = block.timestamp;

        emit PolicyDocumentSet(version, hash, uri, block.timestamp);
    }

    function changePolicyAdmin(address newAdmin) external onlyAdmin {
        if (newAdmin == address(0)) {
            revert CreditPolicy__InvalidAdmin();
        }
        policyAdmin = newAdmin;

        emit PolicyAdminChanged(newAdmin);
    }

    // getters for interface compliance

    function isPolicyActive(uint256 version) external view returns (bool) {
        return policyActive[version];
    }

    function isPolicyFrozen(uint256 version) external view returns (bool) {
        return policyFrozen[version];
    }

    function tierExistsInPolicy(
        uint256 version,
        uint8 tierId
    ) external view returns (bool) {
        return tierExists[version][tierId];
    }

    function setMaxTiers(uint8 _maxTiers) external onlyAdmin {
        if (_maxTiers == 255) {
            revert CreditPolicy__InvalidTierCount(_maxTiers);
        }
        maxTiers = _maxTiers;
        emit MaxTiersChanged(_maxTiers);
    }

    function getMaxTiers() external view returns (uint8) {
        return maxTiers;
    }

    function isIndustryExcluded(
        uint256 version,
        bytes32 industry
    ) external view returns (bool) {
        return excludedIndustries[version][industry];
    }
}


66.1% src/LoanEngine.sol

Lines covered: 84 / 127 (66.1%)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ICreditPolicy} from "./interfaces/ICreditPolicy.sol";
import {IVerifier} from "./interfaces/IVerifier.sol";
import {ITranchePool} from "./interfaces/ITranchePool.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {TranchePool} from "./TranchePool.sol";

contract LoanEngine is Ownable, ReentrancyGuard {
    using SafeERC20 for IERC20;
    /*//////////////////////////////////////////////////////////////
                        ERRORS
    //////////////////////////////////////////////////////////////*/

    error LoanEngine__PolicyNotFrozen(uint256 policyVersion);
    error LoanEngine__InvalidProof();
    error LoanEngine__LoanTierIsNotInPolicy(
        uint256 policyVersion,
        uint8 tierId
    );
    error LoanEngine__InvalidLoanParameters(
        uint256 loanId,
        uint256 principalIssued,
        uint256 aprBps,
        uint256 termDays
    );
    error LoanEngine__MaxOriginationFeeExceeded(
        uint256 loanId,
        uint256 originationFeeBps,
        uint256 maxOriginationFeeBps
    );
    error LoanEngine__PoolNotDeployed();
    error LoanEngine__InvalidOffRampingEntity(address entity);
    error LoanEngine__LoanExists(uint256 loanId);
    error LoanEngine__LoanIsNotInCreatedState(uint256 loanId);
    error LoanEngine__LoanIsNotActive(uint256 loanId);
    error LoanEngine__LoanIsNotDefaulted(uint256 loanId);
    error LoanEngine__InvalidRepayment();
    error LoanEngine__ZeroRecovery();
    error LoanEngine__LoanNotRecoverable(uint256 loanId);
    error LoanEngine__ZeroLossOnWriteOff(uint256 loanId);
    error LoanEngine__InvalidFeeManagerEntity(address manager);
    error LoanEngine__InvalidRecoveryAgent(address agent);
    error LoanEngine__InvalidRepaymentAgent(address agent);
    error LoanEngine__InsufficientPoolLiquidity();
    error LoanEngine__ProofAlreadyUsed();
    modifier isWhiteListedOffRampingEntity(address entity) {
        _isWhiteListedOffRampingEntity(entity);
        _;
    }

    function _isWhiteListedOffRampingEntity(address entity) internal view {
        if (!whitelistedOffRampingEntities[entity]) {
            revert LoanEngine__InvalidOffRampingEntity(entity);
        }
    }

    modifier isWhiteListedRecoveryAgent(address agent) {
        _isWhiteListedRecoveryAgent(agent);
        _;
    }

    function _isWhiteListedRecoveryAgent(address agent) internal view {
        if (!whitelistedRecoveryAgents[agent]) {
            revert LoanEngine__InvalidRecoveryAgent(agent);
        }
    }

    modifier isWhiteListedRepaymentAgent(address agent) {
        _isWhiteListedRepaymentAgent(agent);
        _;
    }

    function _isWhiteListedRepaymentAgent(address agent) internal view {
        if (!whitelistedRepaymentAgents[agent]) {
            revert LoanEngine__InvalidRepaymentAgent(agent);
        }
    }

    modifier isWhiteListedFeeManager(address manager) {
        _isWhiteListedFeeManager(manager);
        _;
    }

    function _isWhiteListedFeeManager(address manager) internal view {
        if (!whitelistedFeeManagers[manager]) {
            revert LoanEngine__InvalidFeeManagerEntity(manager);
        }
    }

    ICreditPolicy public creditPolicyContract;
    IVerifier loanProofVerifier;
    ITranchePool tranchePool;

    mapping(uint256 loanId => Loan) public s_loans;
    mapping(uint256 loanId => uint256) public s_originationFees;
    mapping(address whitelistedOffRampingEntity => bool)
        public whitelistedOffRampingEntities;
    mapping(address whiteListedRecoveryAgent => bool)
        public whitelistedRecoveryAgents;

    mapping(address whiteListedRepaymentAgent => bool)
        public whitelistedRepaymentAgents;

    mapping(address whiteListedFeeManager => bool)
        public whitelistedFeeManagers;
    mapping(bytes32 nullifierHash => bool) public s_nullifierHashes;
    uint256 public s_nextLoanId = 1;
    uint256 public s_maxOriginationFeeBps;
    address public s_stableCoinAddress;
    uint256 public constant STANDARD_BPS = 100;
    enum LoanState {
        NONE,
        CREATED,
        ACTIVE,
        REPAID,
        DEFAULTED,
        WRITTEN_OFF
    }

    struct Loan {
        // Identity
        uint256 loanId;
        bytes32 borrowerCommitment;
        uint256 policyVersion;
        uint8 tierId;
        // Economics
        uint256 principalIssued;
        uint256 principalOutstanding;
        uint256 aprBps;
        uint256 originationFeeBps;
        // Interest accounting
        uint256 interestAccrued;
        uint256 interestPaid;
        uint256 lastAccrualTimestamp;
        // Timing
        uint256 startTimestamp;
        uint256 maturityTimestamp;
        uint256 termDays;
        // State
        LoanState state;
        uint256 totalRecovered;
        // allocation_ratio
        uint256 seniorPrincipalAllocated;
        uint256 juniorPrincipalAllocated;
    }

    /*//////////////////////////////////////////////////////////////
                        EVENTS
    //////////////////////////////////////////////////////////////*/

    event LoanCreated(
        uint256 indexed loanId,
        bytes32 borrowerCommitment,
        uint256 principalIssued,
        uint8 tierId,
        uint256 timestamp
    );

    event LoanActivated(
        uint256 indexed loanId,
        uint256 principalIssued,
        uint256 timestamp,
        uint256 startTimestamp,
        uint256 maturityTimestamp
    );

    event LoanRepaid(
        uint256 indexed loanId,
        uint256 principalRepaid,
        uint256 interestRepaid,
        uint256 timestamp
    );

    event LoanClosed(uint256 indexed loanId, uint256 timestamp);

    event LoanDefaulted(
        uint256 indexed loanId,
        bytes32 reasonHash,
        uint256 timestamp
    );

    event LoanWrittenOff(uint256 indexed loanId, uint256 timestamp);

    event LoanRecovered(
        uint256 indexed loanId,
        uint256 amount,
        uint256 timestamp
    );

    constructor(
        address _creditPolicyContract,
        address _loanProofVerifier,
        uint256 _maxOriginationFeeBps,
        address _tranchePool,
        address _stableCoinAddress
    ) Ownable(msg.sender) {
        creditPolicyContract = ICreditPolicy(_creditPolicyContract);
        loanProofVerifier = IVerifier(_loanProofVerifier);
        s_maxOriginationFeeBps = _maxOriginationFeeBps;
        tranchePool = ITranchePool(_tranchePool);
        s_stableCoinAddress = _stableCoinAddress;
    }

    // A notarization step that records a policy-compliant loan intent on-chain
    // TODO: public inputs needed to be verified against the contract state
    // will be implemented after the public inputs structure is finalized
    // preconditions
    // borrowerCommitment should match the publicinput commitment
    // all the parameteres should match the public inputs
    function createLoan(
        bytes32 borrowerCommitment,
        bytes32 nullifierHash,
        uint256 policyVersion,
        uint8 tierId,
        uint256 principalIssued,
        uint256 aprBps,
        uint256 originationFeeBps,
        uint256 termDays,
        bytes32 industry,
        bytes calldata proofData,
        bytes32[] calldata publicInputs
    ) external onlyOwner {
        if (s_loans[s_nextLoanId].state != LoanState.NONE) {
            revert LoanEngine__LoanExists(s_nextLoanId);
        }
        // Implementation goes here
        if (!creditPolicyContract.isPolicyFrozen(policyVersion)) {
            revert LoanEngine__PolicyNotFrozen(policyVersion);
        }

        if (creditPolicyContract.isIndustryExcluded(policyVersion, industry)) {
            revert LoanEngine__PolicyNotFrozen(policyVersion);
        }

        if (!creditPolicyContract.tierExistsInPolicy(policyVersion, tierId)) {
            revert LoanEngine__LoanTierIsNotInPolicy(policyVersion, tierId);
        }

        if (s_nullifierHashes[nullifierHash]) {
            revert LoanEngine__ProofAlreadyUsed();
        }

        if (loanProofVerifier.verify(proofData, publicInputs) == false) {
            revert LoanEngine__InvalidProof();
        }

        if (
            tranchePool.getPoolState() != TranchePool.PoolState.DEPLOYED &&
            tranchePool.getPoolState() != TranchePool.PoolState.COMMITED
        ) {
            revert LoanEngine__PoolNotDeployed();
        }

        if (principalIssued == 0 || aprBps == 0 || termDays == 0) {
            revert LoanEngine__InvalidLoanParameters(
                s_nextLoanId,
                principalIssued,
                aprBps,
                termDays
            );
        }

        if (originationFeeBps > s_maxOriginationFeeBps) {
            revert LoanEngine__MaxOriginationFeeExceeded(
                s_nextLoanId,
                originationFeeBps,
                s_maxOriginationFeeBps
            );
        }

        if (principalIssued > tranchePool.getTotalIdleValue()) {
            revert LoanEngine__InsufficientPoolLiquidity();
        }

        Loan memory newLoan = Loan({
            loanId: s_nextLoanId,
            borrowerCommitment: borrowerCommitment,
            policyVersion: policyVersion,
            tierId: tierId,
            principalIssued: principalIssued,
            principalOutstanding: 0,
            aprBps: aprBps,
            originationFeeBps: originationFeeBps,
            interestAccrued: 0,
            interestPaid: 0,
            lastAccrualTimestamp: 0,
            startTimestamp: 0,
            maturityTimestamp: 0,
            termDays: termDays,
            state: LoanState.CREATED,
            totalRecovered: 0,
            seniorPrincipalAllocated: 0,
            juniorPrincipalAllocated: 0
        });

        s_loans[s_nextLoanId++] = newLoan;
        s_nullifierHashes[nullifierHash] = true;

        emit LoanCreated(
            newLoan.loanId,
            borrowerCommitment,
            principalIssued,
            tierId,
            block.timestamp
        );
    }

    /*
        preconditions
        - onlyOwner
        - loan must already exist
        - loan.state == CREATED
    */
    function activateLoan(
        uint256 loanId,
        address receivingEntity,
        address feeManager
    )
        external
        onlyOwner
        isWhiteListedOffRampingEntity(receivingEntity)
        isWhiteListedFeeManager(feeManager)
        nonReentrant
    {
        // Implementation goes here
        Loan storage loan = s_loans[loanId];

        if (loan.state != LoanState.CREATED) {
            revert LoanEngine__LoanIsNotInCreatedState(loanId);
        }
        loan.principalOutstanding = loan.principalIssued;
        loan.lastAccrualTimestamp = block.timestamp;
        loan.startTimestamp = block.timestamp;
        loan.maturityTimestamp = block.timestamp + (loan.termDays * 1 days);
        loan.state = LoanState.ACTIVE;

        uint256 originationFee = (loan.principalIssued *
            loan.originationFeeBps) / 10000;

        s_originationFees[loanId] = originationFee;

        if (loan.principalIssued > tranchePool.getTotalIdleValue()) {
            revert LoanEngine__InsufficientPoolLiquidity();
        }

        uint256 totalDisbursement = loan.principalIssued - originationFee;
        (uint256 seniorAmount, uint256 juniorAmount, ) = tranchePool
            .allocateCapital(
                totalDisbursement,
                originationFee,
                receivingEntity,
                feeManager
            );
        loan.seniorPrincipalAllocated = seniorAmount;

        loan.juniorPrincipalAllocated = juniorAmount;

        emit LoanActivated(
            loan.loanId,
            loan.principalIssued,
            block.timestamp,
            loan.startTimestamp,
            loan.maturityTimestamp
        );
    }

    function repayLoan(
        uint256 loanId,
        uint256 principalAmount,
        uint256 interestAmount,
        address repaymentAgent
    )
        external
        onlyOwner
        isWhiteListedRepaymentAgent(repaymentAgent)
        nonReentrant
    {
        Loan storage loan = s_loans[loanId];
        if (loan.state != LoanState.ACTIVE) {
            revert LoanEngine__LoanIsNotActive(loanId);
        }

        uint256 totalPayment = principalAmount + interestAmount;
        if (totalPayment == 0) {
            revert LoanEngine__InvalidRepayment();
        }

        _accrueInterest(loanId);

        // 1️⃣ Transfer funds to pool (settlement layer)
        IERC20(s_stableCoinAddress).safeTransferFrom(
            repaymentAgent,
            address(tranchePool),
            totalPayment
        );

        // 2️⃣ Interest first
        uint256 interestDue = loan.interestAccrued;
        uint256 interestPaid = totalPayment > interestDue
            ? interestDue
            : totalPayment;

        // 3️⃣ Principal second
        uint256 remainingForPrincipal = totalPayment - interestPaid;
        uint256 principalDue = loan.principalOutstanding;

        uint256 principalPaid = remainingForPrincipal > principalDue
            ? principalDue
            : remainingForPrincipal;

        // 4️⃣ Update loan accounting
        loan.interestAccrued -= interestPaid;
        loan.interestPaid += interestPaid;
        loan.principalOutstanding -= principalPaid;

        bool fullyRepaid = loan.principalOutstanding == 0 &&
            loan.interestAccrued == 0;

        if (fullyRepaid) {
            loan.state = LoanState.REPAID;
        }

        tranchePool.onRepayment(principalPaid, interestPaid);

        emit LoanRepaid(
            loan.loanId,
            principalPaid,
            interestPaid,
            block.timestamp
        );

        if (fullyRepaid) {
            emit LoanClosed(loanId, block.timestamp);
        }
    }

    function declareDefault(
        uint256 loanId,
        bytes32 reasonHash
    ) external onlyOwner {
        // Implementation goes here
        Loan storage loan = s_loans[loanId];
        if (loan.state != LoanState.ACTIVE) {
            revert LoanEngine__LoanIsNotActive(loanId);
        }
        _accrueInterest(loanId);
        loan.state = LoanState.DEFAULTED;
        emit LoanDefaulted(loanId, reasonHash, block.timestamp);
    }

    function writeOffLoan(uint256 loanId) external onlyOwner {
        // Implementation goes here
        Loan storage loan = s_loans[loanId];
        if (loan.state != LoanState.DEFAULTED) {
            revert LoanEngine__LoanIsNotDefaulted(loanId);
        }
        uint256 loss = loan.principalOutstanding;
        uint256 interestAccrued = loan.interestAccrued;
        if (loss == 0) {
            revert LoanEngine__ZeroLossOnWriteOff(loanId);
        }

        loan.principalOutstanding = 0;
        loan.interestAccrued = 0;
        loan.state = LoanState.WRITTEN_OFF;
        tranchePool.onLoss(loss, interestAccrued);
        emit LoanWrittenOff(loanId, block.timestamp);
    }

    function recoverLoan(
        uint256 loanId,
        uint256 amount,
        address recoveryAgent
    ) external onlyOwner isWhiteListedRecoveryAgent(recoveryAgent) {
        Loan storage loan = s_loans[loanId];
        if (loan.state != LoanState.WRITTEN_OFF) {
            revert LoanEngine__LoanNotRecoverable(loanId);
        }
        if (amount == 0) {
            revert LoanEngine__ZeroRecovery();
        }
        loan.totalRecovered += amount;
        IERC20(s_stableCoinAddress).safeTransferFrom(
            recoveryAgent,
            address(tranchePool),
            amount
        );
        tranchePool.onRecovery(amount);
        emit LoanRecovered(loanId, amount, block.timestamp);
    }

    function _accrueInterest(uint256 loanId) internal {
        // Implementation goes here
        Loan storage loan = s_loans[loanId];
        if (loan.state != LoanState.ACTIVE) {
            revert LoanEngine__LoanIsNotActive(loanId);
        }
        uint256 timeElapsed = block.timestamp - loan.lastAccrualTimestamp;
        if (loan.principalOutstanding == 0) {
            loan.lastAccrualTimestamp = block.timestamp;
            return;
        }

        uint256 interest = (loan.principalOutstanding *
            loan.aprBps *
            timeElapsed) / (365 days * 10_000);

        if (interest > 0) {
            loan.interestAccrued += interest;
            uint256 totalAllocated = loan.principalIssued;
            uint256 seniorInterest = (interest *
                loan.seniorPrincipalAllocated) / totalAllocated;

            uint256 juniorInterest = (interest *
                loan.juniorPrincipalAllocated) / totalAllocated;
            tranchePool.onInterestAccrued(
                interest,
                seniorInterest,
                juniorInterest
            );
        }
        loan.lastAccrualTimestamp = block.timestamp;
    }

    // setters for contract management

    function setMaxOriginationFeeBps(
        uint256 _maxOriginationFeeBps
    ) external onlyOwner {
        s_maxOriginationFeeBps = _maxOriginationFeeBps;
    }

    function setWhitelistedOffRampingEntity(
        address entity,
        bool isWhitelisted
    ) external onlyOwner {
        whitelistedOffRampingEntities[entity] = isWhitelisted;
    }

    function setWhitelistedRecoveryAgent(
        address agent,
        bool isWhitelisted
    ) external onlyOwner {
        whitelistedRecoveryAgents[agent] = isWhitelisted;
    }

    function setWhitelistedRepaymentAgent(
        address agent,
        bool isWhitelisted
    ) external onlyOwner {
        whitelistedRepaymentAgents[agent] = isWhitelisted;
    }

    function setWhitelistedFeeManager(
        address manager,
        bool isWhitelisted
    ) external onlyOwner {
        whitelistedFeeManagers[manager] = isWhitelisted;
    }

    function getMaxOriginationFeeBps() external view returns (uint256) {
        return s_maxOriginationFeeBps;
    }

    function getNextLoanId() external view returns (uint256) {
        return s_nextLoanId;
    }

    function getLoanDetails(
        uint256 loanId
    ) external view returns (Loan memory) {
        return s_loans[loanId];
    }
}


51.9% src/TranchePool.sol

Lines covered: 219 / 422 (51.9%)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

contract TranchePool is Ownable {
    using SafeERC20 for IERC20;

    // Errors
    error TranchePool__NotWhiteListed(address user);
    error TranchePool__LessThanDepositThreshold(uint256 amount);
    error TranchePool__InvalidAllocationRatio();
    error TranchePool__InsufficientLiquidity();
    error TranchePool__InsufficientShares();
    error TranchePool__ZeroWithdrawal();
    error TranchePool__NotWhiteListedForEquityTranche(address user);
    error TranchePool__InvalidTransferAmount(uint256 amount);
    error TranchePool__InvalidCaller(address user);
    error TranchePool__ZeroAPRError();
    error TranchePool__LossExceededCapital(uint256 remaining);
    error TranchePool__ZeroSharesMinted();
    error TranchePool__PoolIsNotOpen();
    error TranchePool__InvalidStateTransition(PoolState state);
    error TranchePool__WithdrawNotAllowed(PoolState state);
    error TranchePool__ZeroValueError();
    error TranchePool__MaxDepositCapExceeded(uint256 maxCap, uint256 amount);
    error TranchePool__PoolIsNotCommited();
    error TranchePool__PrincipalRepaymentExceeded();
    error TranchePool__ZeroAddressError();
    error TranchePool__DeployedCapitalExists();
    error TranchePool__InvalidMaxCapAmount();
    error TranchePool__InvalidMinDepositAmount();
    error TranchePool__InterestNotClaimed();
    // Events

    event PoolStateUpdated(PoolState newState);

    event LossAllocated(
        uint256 seniorLoss,
        uint256 juniorLoss,
        uint256 equityLoss
    );
    event WithdrawnFromSeniorTranche(
        address indexed user,
        uint256 amount,
        uint256 sharesBurned,
        uint256 time
    );
    event WithdrawnFromJuniorTranche(
        address indexed user,
        uint256 amount,
        uint256 sharesBurned,
        uint256 time
    );
    event WithdrawnFromEquityTranche(
        address indexed user,
        uint256 amount,
        uint256 sharesBurned,
        uint256 time
    );

    event FundsDepositedToSeniorTranche(
        address indexed user,
        uint256 amount,
        uint256 shares,
        uint256 time
    );
    event FundsDepositedToJuniorTranche(
        address indexed user,
        uint256 amount,
        uint256 shares,
        uint256 time
    );
    event FundsDepositedToEquityTranche(
        address indexed user,
        uint256 amount,
        uint256 shares,
        uint256 time
    );
    event CapitalAllocated(
        uint256 seniorAmount,
        uint256 juniorAmount,
        uint256 equityAmount,
        uint256 time
    );
    event RecoverAmountTransferredToTranchePool(
        uint256 amount,
        uint256 timeStamp
    );
    event ProfitTransferredToTranchePool(uint256 amount, uint256 timeStamp);
    event CapitalAllocationFactorUpdatedSenior(uint256 newFactor);
    event CapitalAllocationFactorUpdatedJunior(uint256 newFactor);

    enum PoolState {
        OPEN, // deposits allowed
        COMMITED,
        DEPLOYED, // capital deployed, deposits paused
        CLOSED // withdrawals only
    }

    // Whitelist
    mapping(address => bool) public whiteListedLps;
    mapping(address => bool) public whiteListedForEquityTranche;

    // Shares tracking (instead of amounts)
    mapping(address => uint256) public s_seniorTrancheShares;
    mapping(address => uint256) public s_juniorTrancheShares;
    mapping(address => uint256) public s_equityTrancheShares;

    uint256 public s_totalSeniorShares;
    uint256 public s_totalJuniorShares;
    uint256 public s_totalEquityShares;

    // Total value in each tranche (this decreases when capital is allocated)
    // why some part of the capital should stay idle.
    // 1. Liquidity and operational buffer.
    //
    uint256 public s_seniorTrancheIdleValue;
    uint256 public s_juniorTrancheIdleValue;
    uint256 public s_equityTrancheIdleValue;

    uint256 public s_seniorTrancheDeployedValue;
    uint256 public s_juniorTrancheDeployedValue;
    uint256 public s_equityTrancheDeployedValue;

    // Minimum deposits
    uint256 public s_minimumDepositAmountSeniorTranche;
    uint256 public s_minimumDepositAmountJuniorTranche;
    uint256 public s_minimumDepositAmountEquityTranche;

    // CHANGED: global interest index (scaled)
    uint256 public seniorInterestIndex; // 1e18 precision
    uint256 public juniorInterestIndex; // 1e18 precision
    uint256 public equityInterestIndex; // 1e18 precision

    // CHANGED: per-user last claimed index
    mapping(address => uint256) public seniorUserIndex;
    mapping(address => uint256) public juniorUserIndex;
    mapping(address => uint256) public equityUserIndex;

    // Stable coin
    address public s_stableCoin;
    address public loanEngine;

    // Capital allocation factor (e.g., 80 for 80% senior, 15% junior, 5% equity)
    uint256 public s_capital_allocation_factor_senior;
    uint256 public s_capital_allocation_factor_junior;

    uint256 public s_senior_apr;
    uint256 public s_target_junior_apr;

    uint256 public seniorAccruedInterest;
    uint256 public juniorAccruedInterest;
    uint256 public equityAccruedInterest;

    uint256 public s_seniorTrancheMaxCap;
    uint256 public s_juniorTrancheMaxCap;
    uint256 public s_equityTrancheMaxCap;

    uint256 public s_protocolRevenue;
    uint256 public s_totalDeposited;
    uint256 public s_totalLoss;
    uint256 public s_totalRecovered;

    PoolState public poolState = PoolState.OPEN;

    uint256 public seniorPrincipalShortfall;
    uint256 public juniorPrincipalShortfall;
    uint256 public equityPrincipalShortfall;

    uint256 public s_totalUnclaimedInterest;

    modifier isWhiteListed(address user) {
        _isWhiteListed(user);
        _;
    }

    function _isWhiteListed(address user) internal view {
        if (!whiteListedLps[user]) {
            revert TranchePool__NotWhiteListed(user);
        }
    }

    modifier onlyLoanEngine(address user) {
        _onlyLoanEngine(user);
        _;
    }

    function _onlyLoanEngine(address user) internal view {
        if (user != loanEngine) {
            revert TranchePool__InvalidCaller(user);
        }
    }

    modifier isWhiteListedForEquityTranche(address user) {
        _isWhiteListedForEquityTranche(user);
        _;
    }

    function _isWhiteListedForEquityTranche(address user) internal view {
        if (!whiteListedForEquityTranche[user]) {
            revert TranchePool__NotWhiteListedForEquityTranche(user);
        }
    }

    constructor(address stableCoin_) Ownable(msg.sender) {
        s_stableCoin = stableCoin_;
        seniorInterestIndex = 1e18;
        juniorInterestIndex = 1e18;
        equityInterestIndex = 1e18;
    }

    function depositSeniorTranche(
        uint256 amount
    ) external isWhiteListed(msg.sender) {
        // q: wy we need a minimum deposit for a tranche?
        // a: in book.
        if (poolState != PoolState.OPEN) {
            revert TranchePool__PoolIsNotOpen();
        }
        if (amount == 0) {
            revert TranchePool__ZeroValueError();
        }
        if (amount < s_minimumDepositAmountSeniorTranche) {
            revert TranchePool__LessThanDepositThreshold(amount);
        }
        // why there is a max cap exists?
        //
        //  1. to prevent the liquidity from sitting idle
        //
        if (amount + s_seniorTrancheIdleValue > s_seniorTrancheMaxCap) {
            revert TranchePool__MaxDepositCapExceeded(
                s_seniorTrancheMaxCap,
                amount
            );
        }

        // Calculate shares to mint
        // invariant: the total shares == idle value because the deposit is allowed only when
        // the pool is open and once the pool is moved to a new state new deposits are not allowed
        // so what shares == amount holding 1:1 is valid and is not affecting or opening any attack vectors.
        uint256 shares = amount;

        IERC20(s_stableCoin).safeTransferFrom(
            msg.sender,
            address(this),
            amount
        );

        s_seniorTrancheShares[msg.sender] += shares;
        s_totalSeniorShares += shares;
        s_seniorTrancheIdleValue += amount;
        seniorUserIndex[msg.sender] = seniorInterestIndex;
        s_totalDeposited += amount;
        emit FundsDepositedToSeniorTranche(
            msg.sender,
            amount,
            shares,
            block.timestamp
        );
    }

    function depositJuniorTranche(
        uint256 amount
    ) external isWhiteListed(msg.sender) {
        if (poolState != PoolState.OPEN) {
            revert TranchePool__PoolIsNotOpen();
        }
        if (amount < s_minimumDepositAmountJuniorTranche) {
            revert TranchePool__LessThanDepositThreshold(amount);
        }

        if (amount + s_juniorTrancheIdleValue > s_juniorTrancheMaxCap) {
            revert TranchePool__MaxDepositCapExceeded(
                s_juniorTrancheMaxCap,
                amount
            );
        }

        uint256 shares = amount;

        IERC20(s_stableCoin).safeTransferFrom(
            msg.sender,
            address(this),
            amount
        );

        s_juniorTrancheShares[msg.sender] += shares;
        s_totalJuniorShares += shares;
        s_juniorTrancheIdleValue += amount;
        juniorUserIndex[msg.sender] = juniorInterestIndex;
        s_totalDeposited += amount;

        emit FundsDepositedToJuniorTranche(
            msg.sender,
            amount,
            shares,
            block.timestamp
        );
    }

    function depositEquityTranche(
        uint256 amount
    ) external isWhiteListedForEquityTranche(msg.sender) {
        if (poolState != PoolState.OPEN) {
            revert TranchePool__PoolIsNotOpen();
        }
        if (amount < s_minimumDepositAmountEquityTranche) {
            revert TranchePool__LessThanDepositThreshold(amount);
        }

        if (amount + s_equityTrancheIdleValue > s_equityTrancheMaxCap) {
            revert TranchePool__MaxDepositCapExceeded(
                s_equityTrancheMaxCap,
                amount
            );
        }

        uint256 shares = amount;

        IERC20(s_stableCoin).safeTransferFrom(
            msg.sender,
            address(this),
            amount
        );
        s_equityTrancheShares[msg.sender] += shares;
        s_totalEquityShares += shares;
        s_equityTrancheIdleValue += amount;
        equityUserIndex[msg.sender] = equityInterestIndex;
        s_totalDeposited += amount;

        emit FundsDepositedToEquityTranche(
            msg.sender,
            amount,
            shares,
            block.timestamp
        );
    }

    /**
     * @notice Allocate capital according to the 80/20 split
     * @param totalDisbursement Total amount to allocate from the pool
     * @param fees Total fees to be collected
     */
    function allocateCapital(
        uint256 totalDisbursement,
        uint256 fees,
        address deployer,
        address feeManager
    ) external onlyLoanEngine(msg.sender) returns (uint256, uint256, uint256) {
        if (
            poolState != PoolState.COMMITED && poolState != PoolState.DEPLOYED
        ) {
            revert TranchePool__PoolIsNotCommited();
        }

        uint256 totalAmount = totalDisbursement + fees;

        // Global liquidity check
        uint256 totalIdle = s_seniorTrancheIdleValue +
            s_juniorTrancheIdleValue +
            s_equityTrancheIdleValue;

        if (totalAmount > totalIdle) {
            revert TranchePool__InsufficientLiquidity();
        }

        uint256 targetSenior = (totalAmount *
            s_capital_allocation_factor_senior) / 100;

        uint256 targetJunior = (totalAmount *
            s_capital_allocation_factor_junior) / 100;

        uint256 targetEquity = totalAmount - targetSenior - targetJunior;

        uint256 seniorAmount = _minimum(targetSenior, s_seniorTrancheIdleValue);

        uint256 juniorAmount = _minimum(targetJunior, s_juniorTrancheIdleValue);

        uint256 equityAmount = _minimum(targetEquity, s_equityTrancheIdleValue);

        uint256 allocated = seniorAmount + juniorAmount + equityAmount;

        uint256 remaining = totalAmount - allocated;

        // Equity absorbs first
        if (remaining > 0 && s_equityTrancheIdleValue > equityAmount) {
            uint256 extra = _minimum(
                remaining,
                s_equityTrancheIdleValue - equityAmount
            );
            equityAmount += extra;
            remaining -= extra;
        }

        // Junior absorbs next
        if (remaining > 0 && s_juniorTrancheIdleValue > juniorAmount) {
            uint256 extra = _minimum(
                remaining,
                s_juniorTrancheIdleValue - juniorAmount
            );
            juniorAmount += extra;
            remaining -= extra;
        }

        // Senior absorbs last
        if (remaining > 0 && s_seniorTrancheIdleValue > seniorAmount) {
            uint256 extra = _minimum(
                remaining,
                s_seniorTrancheIdleValue - seniorAmount
            );
            seniorAmount += extra;
            remaining -= extra;
        }

        // Final safety check
        if (remaining > 0) {
            revert TranchePool__InsufficientLiquidity();
        }

        if (poolState == PoolState.COMMITED) {
            poolState = PoolState.DEPLOYED;
            emit PoolStateUpdated(PoolState.DEPLOYED);
        }

        s_seniorTrancheIdleValue -= seniorAmount;
        s_juniorTrancheIdleValue -= juniorAmount;
        s_equityTrancheIdleValue -= equityAmount;

        s_seniorTrancheDeployedValue += seniorAmount;
        s_juniorTrancheDeployedValue += juniorAmount;
        s_equityTrancheDeployedValue += equityAmount;

        IERC20(s_stableCoin).safeTransfer(deployer, totalDisbursement);

        if (fees > 0) {
            IERC20(s_stableCoin).safeTransfer(feeManager, fees);
        }

        emit CapitalAllocated(
            seniorAmount,
            juniorAmount,
            equityAmount,
            block.timestamp
        );
        return (seniorAmount, juniorAmount, equityAmount);
    }

    function onInterestAccrued(
        uint256 interestAmount,
        uint256 seniorInterest,
        uint256 juniorInterest
    ) external onlyLoanEngine(msg.sender) {
        if (interestAmount == 0) return;

        seniorAccruedInterest += seniorInterest;
        juniorAccruedInterest += juniorInterest;
        equityAccruedInterest += (interestAmount -
            seniorInterest -
            juniorInterest);
    }

    function onRepayment(
        uint256 principalRepaid,
        uint256 interestRepaid
    ) external onlyLoanEngine(msg.sender) {
        if (principalRepaid == 0 && interestRepaid == 0) {
            revert TranchePool__InvalidTransferAmount(0);
        }

        /*//////////////////////////////////////////////////////////////
                        INTEREST WATERFALL (INDEXED)
    //////////////////////////////////////////////////////////////*/

        uint256 remainingInterest = interestRepaid;
        s_totalUnclaimedInterest += interestRepaid;

        // 1️⃣ Senior interest
        if (
            remainingInterest > 0 &&
            seniorAccruedInterest > 0 &&
            s_totalSeniorShares > 0
        ) {
            uint256 seniorPaid = _minimum(
                remainingInterest,
                seniorAccruedInterest
            );
            seniorAccruedInterest -= seniorPaid;
            seniorInterestIndex += (seniorPaid * 1e18) / s_totalSeniorShares;
            remainingInterest -= seniorPaid;
        }

        // 2️⃣ Junior interest
        if (
            remainingInterest > 0 &&
            juniorAccruedInterest > 0 &&
            s_totalJuniorShares > 0
        ) {
            uint256 juniorPaid = _minimum(
                remainingInterest,
                juniorAccruedInterest
            );
            juniorAccruedInterest -= juniorPaid;
            juniorInterestIndex += (juniorPaid * 1e18) / s_totalJuniorShares;
            remainingInterest -= juniorPaid;
        }

        // 3️⃣ Equity / overflow interest
        if (remainingInterest > 0) {
            if (s_totalEquityShares > 0) {
                equityInterestIndex +=
                    (remainingInterest * 1e18) /
                    s_totalEquityShares;
                equityAccruedInterest -= _minimum(
                    equityAccruedInterest,
                    remainingInterest
                );
            } else if (s_totalJuniorShares > 0) {
                // no equity → junior gets excess
                juniorInterestIndex +=
                    (remainingInterest * 1e18) /
                    s_totalJuniorShares;
            } else {
                // no LPs left → protocol revenue
                s_protocolRevenue += remainingInterest;
            }
        }

        /*//////////////////////////////////////////////////////////////
                        PRINCIPAL REDEMPTION
            (REVERSE OF LOSS WATERFALL — NO RATIOS)
    //////////////////////////////////////////////////////////////*/

        if (principalRepaid > 0) {
            uint256 remaining = principalRepaid;

            // Senior first (restore safest capital)
            if (remaining > 0 && s_seniorTrancheDeployedValue > 0) {
                uint256 seniorPay = _minimum(
                    remaining,
                    s_seniorTrancheDeployedValue
                );
                s_seniorTrancheDeployedValue -= seniorPay;
                s_seniorTrancheIdleValue += seniorPay;
                remaining -= seniorPay;
            }

            // Junior next
            if (remaining > 0 && s_juniorTrancheDeployedValue > 0) {
                uint256 juniorPay = _minimum(
                    remaining,
                    s_juniorTrancheDeployedValue
                );
                s_juniorTrancheDeployedValue -= juniorPay;
                s_juniorTrancheIdleValue += juniorPay;
                remaining -= juniorPay;
            }

            // Equity last
            if (remaining > 0 && s_equityTrancheDeployedValue > 0) {
                uint256 equityPay = _minimum(
                    remaining,
                    s_equityTrancheDeployedValue
                );
                s_equityTrancheDeployedValue -= equityPay;
                s_equityTrancheIdleValue += equityPay;
                remaining -= equityPay;
            }

            // Safety: should never happen unless LoanEngine lies
            if (remaining > 0) {
                revert TranchePool__PrincipalRepaymentExceeded();
            }
        }
    }

    // lp profit withdrawal is pending but it can only be implemented
    // after the loan enginge implementation which determines how the
    // interest will be accured and the distribution is dependent on the
    // share capacity

    function onLoss(
        uint256 principalLoss,
        uint256 interestAccrued
    ) external onlyLoanEngine(msg.sender) {
        if (principalLoss == 0 && interestAccrued == 0) {
            revert TranchePool__ZeroValueError();
        }

        /*//////////////////////////////////////////////////////////////
                    1️⃣ CANCEL GHOST INTEREST
        (SAME PRIORITY AS INTEREST PAYOUT)
    //////////////////////////////////////////////////////////////*/

        uint256 remainingInterest = interestAccrued;

        // Cancel senior accrued interest first
        if (remainingInterest > 0 && seniorAccruedInterest > 0) {
            uint256 seniorCancel = _minimum(
                remainingInterest,
                seniorAccruedInterest
            );
            seniorAccruedInterest -= seniorCancel;
            remainingInterest -= seniorCancel;
        }

        // Then junior
        if (remainingInterest > 0 && juniorAccruedInterest > 0) {
            uint256 juniorCancel = _minimum(
                remainingInterest,
                juniorAccruedInterest
            );
            juniorAccruedInterest -= juniorCancel;
            remainingInterest -= juniorCancel;
        }

        // Any remaining interest is ignored (equity / protocol had no promise)

        /*//////////////////////////////////////////////////////////////
                    2️⃣ PRINCIPAL LOSS WATERFALL
                Equity → Junior → Senior
    //////////////////////////////////////////////////////////////*/

        s_totalLoss += principalLoss;
        uint256 remaining = principalLoss;

        uint256 equityLoss;
        uint256 juniorLoss;
        uint256 seniorLoss;

        // Equity absorbs first
        if (remaining > 0 && s_equityTrancheDeployedValue > 0) {
            equityLoss = _minimum(remaining, s_equityTrancheDeployedValue);
            s_equityTrancheDeployedValue -= equityLoss;
            equityPrincipalShortfall += equityLoss;
            remaining -= equityLoss;
        }

        // Junior next
        if (remaining > 0 && s_juniorTrancheDeployedValue > 0) {
            juniorLoss = _minimum(remaining, s_juniorTrancheDeployedValue);
            s_juniorTrancheDeployedValue -= juniorLoss;
            juniorPrincipalShortfall += juniorLoss;
            remaining -= juniorLoss;
        }

        // Senior last
        if (remaining > 0 && s_seniorTrancheDeployedValue > 0) {
            seniorLoss = _minimum(remaining, s_seniorTrancheDeployedValue);
            s_seniorTrancheDeployedValue -= seniorLoss;
            seniorPrincipalShortfall += seniorLoss;
            remaining -= seniorLoss;
        }

        if (remaining > 0) {
            revert TranchePool__LossExceededCapital(remaining);
        }

        emit LossAllocated(seniorLoss, juniorLoss, equityLoss);
    }

    // on recovery what happens is the protocol may recover more than he lost and it can cause appreciation of the share value when withdrawing, keeping the design simple because adding it to interest accured make no difference at the end of withdrawing.

    function onRecovery(uint256 amount) external onlyLoanEngine(msg.sender) {
        if (amount == 0) {
            revert TranchePool__ZeroValueError();
        }

        s_totalRecovered += amount;
        uint256 remaining = amount;

        // Senior first
        if (remaining > 0 && seniorPrincipalShortfall > 0) {
            uint256 seniorPay = _minimum(remaining, seniorPrincipalShortfall);
            seniorPrincipalShortfall -= seniorPay;
            s_seniorTrancheIdleValue += seniorPay;
            remaining -= seniorPay;
        }

        // Junior next
        if (remaining > 0 && juniorPrincipalShortfall > 0) {
            uint256 juniorPay = _minimum(remaining, juniorPrincipalShortfall);
            juniorPrincipalShortfall -= juniorPay;
            s_juniorTrancheIdleValue += juniorPay;
            remaining -= juniorPay;
        }

        // Equity last
        if (remaining > 0 && equityPrincipalShortfall > 0) {
            uint256 equityPay = _minimum(remaining, equityPrincipalShortfall);
            equityPrincipalShortfall -= equityPay;
            s_equityTrancheIdleValue += equityPay;
            remaining -= equityPay;
        }

        // Any excess is true upside → equity
        if (remaining > 0) {
            s_equityTrancheIdleValue += remaining;
        }

        emit RecoverAmountTransferredToTranchePool(amount, block.timestamp);
    }

    // when the pool closes if the user withdraw the shares before claiming interest on those he will lose the interest for the withdrawn shares
    function claimSeniorInterest() external {
        uint256 userShares = s_seniorTrancheShares[msg.sender];
        if (userShares == 0) revert TranchePool__InsufficientShares();

        uint256 indexDelta = seniorInterestIndex - seniorUserIndex[msg.sender];

        if (indexDelta == 0) revert TranchePool__ZeroWithdrawal();

        uint256 claimable = (userShares * indexDelta) / 1e18;

        // CHANGED: update user index BEFORE transfer
        seniorUserIndex[msg.sender] = seniorInterestIndex;
        s_totalUnclaimedInterest -= claimable;

        IERC20(s_stableCoin).safeTransfer(msg.sender, claimable);
    }

    function claimJuniorInterest() external {
        uint256 userShares = s_juniorTrancheShares[msg.sender];
        if (userShares == 0) revert TranchePool__InsufficientShares();

        uint256 indexDelta = juniorInterestIndex - juniorUserIndex[msg.sender];

        if (indexDelta == 0) revert TranchePool__ZeroWithdrawal();

        uint256 claimable = (userShares * indexDelta) / 1e18;

        // CHANGED: update user index BEFORE transfer
        juniorUserIndex[msg.sender] = juniorInterestIndex;
        s_totalUnclaimedInterest -= claimable;

        IERC20(s_stableCoin).safeTransfer(msg.sender, claimable);
    }

    function claimEquityInterest()
        external
        isWhiteListedForEquityTranche(msg.sender)
    {
        uint256 userShares = s_equityTrancheShares[msg.sender];
        if (userShares == 0) revert TranchePool__InsufficientShares();

        uint256 indexDelta = equityInterestIndex - equityUserIndex[msg.sender];

        if (indexDelta == 0) revert TranchePool__ZeroWithdrawal();

        uint256 claimable = (userShares * indexDelta) / 1e18;
        s_totalUnclaimedInterest -= claimable;

        // CHANGED: update user index BEFORE transfer
        equityUserIndex[msg.sender] = equityInterestIndex;

        IERC20(s_stableCoin).safeTransfer(msg.sender, claimable);
    }

    /**
     *
     *
     * @notice Withdraw from senior tranche by burning shares
     * @param shares Number of shares to burn (0 = withdraw all)
     * passing zero amount will cause the burn of all shares
     */
    function withdrawSeniorTranche(
        uint256 shares
    ) external isWhiteListed(msg.sender) {
        if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) {
            revert TranchePool__WithdrawNotAllowed(poolState);
        }
        uint256 userShares = s_seniorTrancheShares[msg.sender];

        if (userShares == 0) {
            revert TranchePool__InsufficientShares();
        }

        // If shares is 0, withdraw everything
        uint256 sharesToBurn = shares == 0 ? userShares : shares;

        if (sharesToBurn > userShares) {
            revert TranchePool__InsufficientShares();
        }

        // Calculate amount to withdraw based on current pool value
        uint256 amountToWithdraw = (sharesToBurn * s_seniorTrancheIdleValue) /
            s_totalSeniorShares;

        if (seniorUserIndex[msg.sender] != seniorInterestIndex) {
            revert TranchePool__InterestNotClaimed();
        }

        if (amountToWithdraw == 0) {
            revert TranchePool__ZeroWithdrawal();
        }

        if (amountToWithdraw > s_seniorTrancheIdleValue) {
            revert TranchePool__InsufficientLiquidity();
        }

        // Update state before transfer (CEI pattern)
        s_seniorTrancheShares[msg.sender] -= sharesToBurn;
        s_totalSeniorShares -= sharesToBurn;
        s_seniorTrancheIdleValue -= amountToWithdraw;
        s_totalDeposited -= amountToWithdraw;
        // Transfer tokens
        IERC20(s_stableCoin).safeTransfer(msg.sender, amountToWithdraw);

        emit WithdrawnFromSeniorTranche(
            msg.sender,
            amountToWithdraw,
            sharesToBurn,
            block.timestamp
        );
    }

    /**
     * @notice Withdraw from junior tranche by burning shares
     * @param shares Number of shares to burn (0 = withdraw all)
     */
    function withdrawJuniorTranche(
        uint256 shares
    ) external isWhiteListed(msg.sender) {
        if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) {
            revert TranchePool__WithdrawNotAllowed(poolState);
        }
        uint256 userShares = s_juniorTrancheShares[msg.sender];

        if (userShares == 0) {
            revert TranchePool__InsufficientShares();
        }

        if (juniorUserIndex[msg.sender] != juniorInterestIndex) {
            revert TranchePool__InterestNotClaimed();
        }

        uint256 sharesToBurn = shares == 0 ? userShares : shares;

        if (sharesToBurn > userShares) {
            revert TranchePool__InsufficientShares();
        }

        uint256 amountToWithdraw = (sharesToBurn * s_juniorTrancheIdleValue) /
            s_totalJuniorShares;

        if (amountToWithdraw == 0) {
            revert TranchePool__ZeroWithdrawal();
        }
        if (amountToWithdraw > s_juniorTrancheIdleValue) {
            revert TranchePool__InsufficientLiquidity();
        }

        s_juniorTrancheShares[msg.sender] -= sharesToBurn;
        s_totalJuniorShares -= sharesToBurn;
        s_juniorTrancheIdleValue -= amountToWithdraw;
        s_totalDeposited -= amountToWithdraw;

        IERC20(s_stableCoin).safeTransfer(msg.sender, amountToWithdraw);

        emit WithdrawnFromJuniorTranche(
            msg.sender,
            amountToWithdraw,
            sharesToBurn,
            block.timestamp
        );
    }

    function withdrawEquityTranche(
        uint256 shares
    ) external isWhiteListedForEquityTranche(msg.sender) {
        if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) {
            revert TranchePool__WithdrawNotAllowed(poolState);
        }
        uint256 userShares = s_equityTrancheShares[msg.sender];

        if (userShares == 0) {
            revert TranchePool__InsufficientShares();
        }
        if (equityUserIndex[msg.sender] != equityInterestIndex) {
            revert TranchePool__InterestNotClaimed();
        }
        uint256 sharesToBurn = shares == 0 ? userShares : shares;
        if (sharesToBurn > userShares) {
            revert TranchePool__InsufficientShares();
        }

        uint256 amountToWithdraw = (sharesToBurn * s_equityTrancheIdleValue) /
            s_totalEquityShares;

        if (amountToWithdraw == 0) {
            revert TranchePool__ZeroWithdrawal();
        }
        if (amountToWithdraw > s_equityTrancheIdleValue) {
            revert TranchePool__InsufficientLiquidity();
        }
        s_equityTrancheShares[msg.sender] -= sharesToBurn;
        s_totalEquityShares -= sharesToBurn;
        s_equityTrancheIdleValue -= amountToWithdraw;
        s_totalDeposited -= amountToWithdraw;

        IERC20(s_stableCoin).safeTransfer(msg.sender, amountToWithdraw);

        emit WithdrawnFromEquityTranche(
            msg.sender,
            amountToWithdraw,
            sharesToBurn,
            block.timestamp
        );
    }

    /**
     * @notice Withdraw specific amount from senior tranche
     * @param amount Amount of tokens to withdraw
     */
    function withdrawSeniorTrancheByAmount(
        uint256 amount
    ) external isWhiteListed(msg.sender) {
        if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) {
            revert TranchePool__WithdrawNotAllowed(poolState);
        }
        if (amount == 0) {
            revert TranchePool__ZeroWithdrawal();
        }
        if (seniorUserIndex[msg.sender] != seniorInterestIndex) {
            revert TranchePool__InterestNotClaimed();
        }

        uint256 userBalance = getSeniorTrancheBalance(msg.sender);

        if (amount > userBalance) {
            revert TranchePool__InsufficientShares();
        }

        if (amount > s_seniorTrancheIdleValue) {
            revert TranchePool__InsufficientLiquidity();
        }

        // Calculate shares to burn for this amount
        uint256 sharesToBurn = (amount * s_totalSeniorShares) /
            (s_seniorTrancheIdleValue);

        // Handle rounding - ensure we don't try to withdraw more than available
        if (sharesToBurn > s_seniorTrancheShares[msg.sender]) {
            sharesToBurn = s_seniorTrancheShares[msg.sender];
        }

        s_seniorTrancheShares[msg.sender] -= sharesToBurn;
        s_totalSeniorShares -= sharesToBurn;
        s_seniorTrancheIdleValue -= amount;
        s_totalDeposited -= amount;

        IERC20(s_stableCoin).safeTransfer(msg.sender, amount);

        emit WithdrawnFromSeniorTranche(
            msg.sender,
            amount,
            sharesToBurn,
            block.timestamp
        );
    }

    /**
     * @notice Withdraw specific amount from junior tranche
     * @param amount Amount of tokens to withdraw
     */
    function withdrawJuniorTrancheByAmount(
        uint256 amount
    ) external isWhiteListed(msg.sender) {
        if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) {
            revert TranchePool__WithdrawNotAllowed(poolState);
        }
        if (amount == 0) {
            revert TranchePool__ZeroWithdrawal();
        }

        if (juniorUserIndex[msg.sender] != juniorInterestIndex) {
            revert TranchePool__InterestNotClaimed();
        }

        uint256 userBalance = getJuniorTrancheBalance(msg.sender);

        if (amount > userBalance) {
            revert TranchePool__InsufficientShares();
        }

        if (amount > s_juniorTrancheIdleValue) {
            revert TranchePool__InsufficientLiquidity();
        }

        uint256 sharesToBurn = (amount * s_totalJuniorShares) /
            (s_juniorTrancheIdleValue);

        if (sharesToBurn > s_juniorTrancheShares[msg.sender]) {
            sharesToBurn = s_juniorTrancheShares[msg.sender];
        }

        s_juniorTrancheShares[msg.sender] -= sharesToBurn;
        s_totalJuniorShares -= sharesToBurn;
        s_juniorTrancheIdleValue -= amount;
        s_totalDeposited -= amount;

        IERC20(s_stableCoin).safeTransfer(msg.sender, amount);

        emit WithdrawnFromJuniorTranche(
            msg.sender,
            amount,
            sharesToBurn,
            block.timestamp
        );
    }

    function withdrawEquityTrancheByAmount(
        uint256 amount
    ) external isWhiteListedForEquityTranche(msg.sender) {
        if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) {
            revert TranchePool__WithdrawNotAllowed(poolState);
        }
        if (amount == 0) {
            revert TranchePool__ZeroWithdrawal();
        }

        if (equityUserIndex[msg.sender] != equityInterestIndex) {
            revert TranchePool__InterestNotClaimed();
        }

        uint256 userBalance = getEquityTrancheBalance(msg.sender);

        if (amount > userBalance) {
            revert TranchePool__InsufficientShares();
        }

        if (amount > s_equityTrancheIdleValue) {
            revert TranchePool__InsufficientLiquidity();
        }

        uint256 sharesToBurn = (amount * s_totalEquityShares) /
            (s_equityTrancheIdleValue);

        if (sharesToBurn > s_equityTrancheShares[msg.sender]) {
            sharesToBurn = s_equityTrancheShares[msg.sender];
        }

        s_equityTrancheShares[msg.sender] -= sharesToBurn;
        s_totalEquityShares -= sharesToBurn;
        s_equityTrancheIdleValue -= amount;
        s_totalDeposited -= amount;

        IERC20(s_stableCoin).safeTransfer(msg.sender, amount);

        emit WithdrawnFromEquityTranche(
            msg.sender,
            amount,
            sharesToBurn,
            block.timestamp
        );
    }

    /**
     * @notice Get the current balance of a user in the senior tranche
     */
    function getSeniorTrancheBalance(
        address user
    ) public view returns (uint256) {
        if (s_totalSeniorShares == 0) return 0;
        return
            (s_seniorTrancheShares[user] * s_seniorTrancheIdleValue) /
            s_totalSeniorShares;
    }

    /**
     * @notice Get the current balance of a user in the junior tranche
     */
    function getJuniorTrancheBalance(
        address user
    ) public view returns (uint256) {
        if (s_totalJuniorShares == 0) return 0;
        return
            (s_juniorTrancheShares[user] * s_juniorTrancheIdleValue) /
            s_totalJuniorShares;
    }

    function getEquityTrancheBalance(
        address user
    ) public view returns (uint256) {
        if (s_totalEquityShares == 0) return 0;
        return
            (s_equityTrancheShares[user] * s_equityTrancheIdleValue) /
            s_totalEquityShares;
    }

    // Admin functions
    function setMinimumDepositAmountJuniorTranche(
        uint256 amount
    ) external onlyOwner {
        if (amount > s_juniorTrancheMaxCap) {
            revert TranchePool__InvalidMinDepositAmount();
        }
        s_minimumDepositAmountJuniorTranche = amount;
    }

    function setMinimumDepositAmountSeniorTranche(
        uint256 amount
    ) external onlyOwner {
        if (amount > s_seniorTrancheMaxCap) {
            revert TranchePool__InvalidMinDepositAmount();
        }
        s_minimumDepositAmountSeniorTranche = amount;
    }

    function setMinimumDepositAmountEquityTranche(
        uint256 amount
    ) external onlyOwner {
        if (amount > s_equityTrancheMaxCap) {
            revert TranchePool__InvalidMinDepositAmount();
        }
        s_minimumDepositAmountEquityTranche = amount;
    }

    function setTrancheCapitalAllocationFactorSenior(
        uint256 factor
    ) external onlyOwner {
        if (factor + s_capital_allocation_factor_junior > 100)
            revert TranchePool__InvalidAllocationRatio();
        s_capital_allocation_factor_senior = factor;
        emit CapitalAllocationFactorUpdatedSenior(factor);
    }

    function setTrancheCapitalAllocationFactorJunior(
        uint256 factor
    ) external onlyOwner {
        if (factor + s_capital_allocation_factor_senior > 100)
            revert TranchePool__InvalidAllocationRatio();
        s_capital_allocation_factor_junior = factor;
        emit CapitalAllocationFactorUpdatedJunior(factor);
    }

    function setSeniorAPR(uint256 apr) external onlyOwner {
        if (apr == 0) {
            revert TranchePool__ZeroAPRError();
        }
        s_senior_apr = apr;
    }

    function setTargetJuniorAPR(uint256 apr) external onlyOwner {
        if (apr == 0) {
            revert TranchePool__ZeroAPRError();
        }
        s_target_junior_apr = apr;
    }

    function setPoolState(PoolState newState) external onlyOwner {
        if (uint256(newState) < uint256(poolState)) {
            revert TranchePool__InvalidStateTransition(newState);
        }

        if (newState == PoolState.CLOSED) {
            if (getTotalDeployedValue() > 0) {
                revert TranchePool__DeployedCapitalExists();
            }
        }

        poolState = newState;

        emit PoolStateUpdated(newState);
    }

    function setLoanEngine(address _loanEngine) external onlyOwner {
        if (_loanEngine == address(0)) {
            revert TranchePool__ZeroAddressError();
        }
        loanEngine = _loanEngine;
    }

    function setMaxAllocationCapSeniorTranche(
        uint256 amount
    ) external onlyOwner {
        if (amount == 0) {
            revert TranchePool__ZeroValueError();
        }
        if (amount < s_minimumDepositAmountSeniorTranche) {
            revert TranchePool__InvalidMaxCapAmount();
        }
        s_seniorTrancheMaxCap = amount;
    }

    function setMaxAllocationCapJuniorTranche(
        uint256 amount
    ) external onlyOwner {
        if (amount == 0) {
            revert TranchePool__ZeroValueError();
        }
        if (amount < s_minimumDepositAmountJuniorTranche) {
            revert TranchePool__InvalidMaxCapAmount();
        }
        s_juniorTrancheMaxCap = amount;
    }

    function setMaxAllocationCapEquityTranche(
        uint256 amount
    ) external onlyOwner {
        if (amount == 0) {
            revert TranchePool__ZeroValueError();
        }
        if (amount < s_minimumDepositAmountEquityTranche) {
            revert TranchePool__InvalidMaxCapAmount();
        }
        s_equityTrancheMaxCap = amount;
    }

    function updateWhitelist(address user, bool status) external onlyOwner {
        whiteListedLps[user] = status;
    }

    function updateEquityTrancheWhiteList(
        address user,
        bool status
    ) external onlyOwner {
        whiteListedForEquityTranche[user] = status;
    }

    function _minimum(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a > b) {
            return b;
        } else {
            return a;
        }
    }

    // getters

    function getTotalUnclaimedInterest() external view returns (uint256) {
        return s_totalUnclaimedInterest;
    }

    function getSeniorTrancheMaxDepositCap() external view returns (uint256) {
        return s_seniorTrancheMaxCap;
    }

    function getSeniorTrancheMinimumDepositAmount()
        external
        view
        returns (uint256)
    {
        return s_minimumDepositAmountSeniorTranche;
    }

    function getSeniorTrancheShares(
        address user
    ) external view returns (uint256) {
        return s_seniorTrancheShares[user];
    }

    function getTotalSeniorShares() external view returns (uint256) {
        return s_totalSeniorShares;
    }

    function getSeniorTrancheIdleValue() external view returns (uint256) {
        return s_seniorTrancheIdleValue;
    }

    function getSeniorTrancheDeployedValue() external view returns (uint256) {
        return s_seniorTrancheDeployedValue;
    }

    function getSeniorInterestIndex() external view returns (uint256) {
        return seniorInterestIndex;
    }

    function getSeniorUserIndex(address user) external view returns (uint256) {
        return seniorUserIndex[user];
    }

    function getJuniorTrancheMaxDepositCap() external view returns (uint256) {
        return s_juniorTrancheMaxCap;
    }

    function getJuniorInterestIndex() external view returns (uint256) {
        return juniorInterestIndex;
    }

    function getJuniorTrancheMinimumDepositAmount()
        external
        view
        returns (uint256)
    {
        return s_minimumDepositAmountJuniorTranche;
    }

    function getJuniorTrancheShares(
        address user
    ) external view returns (uint256) {
        return s_juniorTrancheShares[user];
    }

    function getTotalJuniorShares() external view returns (uint256) {
        return s_totalJuniorShares;
    }

    function getJuniorTrancheIdleValue() external view returns (uint256) {
        return s_juniorTrancheIdleValue;
    }

    function getJuniorTrancheDeployedValue() external view returns (uint256) {
        return s_juniorTrancheDeployedValue;
    }

    function getJuniorUserIndex(address user) external view returns (uint256) {
        return juniorUserIndex[user];
    }

    function getEquityTrancheMaxDepositCap() external view returns (uint256) {
        return s_equityTrancheMaxCap;
    }

    function getEquityTrancheShares(
        address user
    ) external view returns (uint256) {
        return s_equityTrancheShares[user];
    }

    function getTotalEquityShares() external view returns (uint256) {
        return s_totalEquityShares;
    }

    function getEquityTrancheMinimumDepositAmount()
        external
        view
        returns (uint256)
    {
        return s_minimumDepositAmountEquityTranche;
    }

    function getEquityTrancheIdleValue() external view returns (uint256) {
        return s_equityTrancheIdleValue;
    }

    function getEquityTrancheDeployedValue() external view returns (uint256) {
        return s_equityTrancheDeployedValue;
    }

    function getEquityInterestIndex() external view returns (uint256) {
        return equityInterestIndex;
    }

    function getEquityUserIndex(address user) external view returns (uint256) {
        return equityUserIndex[user];
    }

    function getPoolState() external view returns (PoolState) {
        return poolState;
    }

    function getTotalDeployedValue() public view returns (uint256) {
        return
            s_seniorTrancheDeployedValue +
            s_juniorTrancheDeployedValue +
            s_equityTrancheDeployedValue;
    }

    function getTotalIdleValue() external view returns (uint256) {
        return
            s_seniorTrancheIdleValue +
            s_juniorTrancheIdleValue +
            s_equityTrancheIdleValue;
    }

    function getSeniorAllocationRatio() external view returns (uint256) {
        return s_capital_allocation_factor_senior;
    }

    function getJuniorAllocationRatio() external view returns (uint256) {
        return s_capital_allocation_factor_junior;
    }

    function getTotalDeposited() external view returns (uint256) {
        return s_totalDeposited;
    }

    function getTotalLoss() external view returns (uint256) {
        return s_totalLoss;
    }

    function getTotalRecovered() external view returns (uint256) {
        return s_totalRecovered;
    }

    function getProtocolRevenue() external view returns (uint256) {
        return s_protocolRevenue;
    }

    function getSeniorPrincipalShortfall() external view returns (uint256) {
        return seniorPrincipalShortfall;
    }

    function getJuniorPrincipalShortfall() external view returns (uint256) {
        return juniorPrincipalShortfall;
    }

    function getEquityPrincipalShortfall() external view returns (uint256) {
        return equityPrincipalShortfall;
    }
}


0.0% src/interfaces/ICreditPolicy.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import {CreditPolicy} from "../CreditPolicy.sol";

interface ICreditPolicy {
    function createPolicy(uint256 version) external;

    function freezePolicy(uint256 version) external;

    function deActivatePolicy(uint256 version) external;

    function updateEligibility(
        uint256 version,
        CreditPolicy.EligibilityCriteria calldata data
    ) external;

    function updateRatios(
        uint256 version,
        CreditPolicy.FinancialRatios calldata data
    ) external;

    function updateConcentration(
        uint256 version,
        CreditPolicy.ConcentrationLimits calldata data
    ) external;

    function updateAttestation(
        uint256 version,
        CreditPolicy.AttestationRequirements calldata data
    ) external;

    function updateCovenants(
        uint256 version,
        CreditPolicy.MaintenanceCovenants calldata data
    ) external;

    function setLoanTier(
        uint256 version,
        uint8 tierId,
        CreditPolicy.LoanTier calldata tier
    ) external;

    function excludeIndustry(uint256 version, bytes32 industry) external;

    function includeIndustry(uint256 version, bytes32 industry) external;

    function setPolicyDocument(
        uint256 version,
        bytes32 hash,
        string calldata uri
    ) external;

    function tierExistsInPolicy(
        uint256 version,
        uint8 tierId
    ) external view returns (bool);

    function changePolicyAdmin(address newAdmin) external;

    function isPolicyActive(uint256 version) external view returns (bool);

    function isPolicyFrozen(uint256 version) external view returns (bool);

    function isIndustryExcluded(
        uint256 version,
        bytes32 industry
    ) external view returns (bool);
}


0.0% src/interfaces/ITranchePool.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import {TranchePool} from "../TranchePool.sol";

interface ITranchePool {
    // logic functions

    function withdrawEquityTrancheByAmount(uint256 amount) external;

    function withdrawJuniorTrancheByAmount(uint256 amount) external;

    function withdrawSeniorTrancheByAmount(uint256 amount) external;

    function withdrawEquityTranche(uint256 shares) external;

    function withdrawJuniorTranche(uint256 shares) external;

    function withdrawSeniorTranche(uint256 shares) external;

    function onInterestAccrued(
        uint256 interestAmount,
        uint256 seniorInterest,
        uint256 juniorInterest
    ) external;

    function onRepayment(
        uint256 principalRepaid,
        uint256 interestRepaid
    ) external;

    function onRecovery(uint256 amount) external;

    function allocateCapital(
        uint256 totalDisbursement,
        uint256 fees,
        address deployer,
        address feeManager
    )
        external
        returns (
            uint256 seniorAmount,
            uint256 juniorAmount,
            uint256 equityAmount
        );

    function depositEquityTranche(uint256 amount) external;

    function depositJuniorTranche(uint256 amount) external;

    function depositSeniorTranche(uint256 amount) external;

    // updaters
    function updateEquityTrancheWhiteList(address user, bool status) external;

    function updateWhitelist(address user, bool status) external;

    // setters

    function onLoss(uint256 principalLoss, uint256 interestAccrued) external;

    function setLoanEngine(address _loanEngine) external;

    function setTargetJuniorAPR(uint256 apr) external;

    function setSeniorAPR(uint256 apr) external;

    function setTrancheCapitalAllocationFactorJunior(uint256 factor) external;

    function setTrancheCapitalAllocationFactorSenior(uint256 factor) external;

    function setMinimumDepositAmountEquityTranche(uint256 amount) external;

    function setMinimumDepositAmountSeniorTranche(uint256 amount) external;

    function setMinimumDepositAmountJuniorTranche(uint256 amount) external;

    // getters
    function getEquityTrancheBalance(
        address user
    ) external view returns (uint256);

    function getJuniorTrancheBalance(
        address user
    ) external view returns (uint256);

    function getSeniorTrancheBalance(
        address user
    ) external view returns (uint256);

    function getPoolState() external view returns (TranchePool.PoolState);

    function getSeniorAllocationRatio() external view returns (uint256);

    function getJuniorAllocationRatio() external view returns (uint256);

    function getTotalIdleValue() external view returns (uint256);
}


0.0% src/interfaces/IVerifier.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IVerifier {
    function verify(
        bytes calldata _proof,
        bytes32[] calldata _publicInputs
    ) external returns (bool);
}


80.5% test/medusa/MedusaTest.sol

Lines covered: 235 / 292 (80.5%)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import {LoanEngine} from "../../src/LoanEngine.sol";
import {TranchePool} from "../../src/TranchePool.sol";
import {CreditPolicy} from "../../src/CreditPolicy.sol";
import {MockLoanProofVerifier} from "../mocks/MockLoanProofVerifier.sol";
import {ERC20Mock} from "@openzeppelin/contracts/mocks/token/ERC20Mock.sol";

contract MedusaTest {
    LoanEngine public loanEngine;
    TranchePool public tranchePool;
    ERC20Mock public usdt;
    CreditPolicy public creditPolicy;
    
    uint256 public constant USDT = 1e18;
    address public deployer = address(0x999);
    address public recevingEntity = address(0x888);
    address public feeManager = address(0x777);
    
    // Configuration constants (matching Foundry handler)
    bool public allowFullDeployment = true;
    uint256 public minimumLoanPrincipal = 10_00_000 * USDT;
    uint256 public maximumLoanPrincipal = 2_00_00_000 * USDT;
    uint256 public minimumOriginationFeeBps = 50;
    uint256 public minimumTermDays = 180;
    uint256 public maximumTermDays = 480;
    uint256 public activePolicyVersion = 1;
    
    // Counters
    uint256 public defaultCounter;
    uint256 public writeOffCounter;
    uint256 public recoveryCounter;
    
    // Users
    address[] public seniorUsers;
    address[] public juniorUsers;
    address[] public equityUsers;
    address[] public loanBorrowers;
    
    // Ghost variables for tracking (matching Foundry handler)
    uint256 public totalIdleValue;
    uint256 public totalDeployedValue;
    uint256 public totalDeposited;
    uint256 public totalLoss;
    uint256 public totalRecovered;
    uint256 public totalUnclaimedInterest;
    uint256 public outStandingPrincipal;
    
    // VM cheatcodes interface
    Hevm internal constant vm = Hevm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
    
    constructor() {
        // Deploy contracts
        usdt = new ERC20Mock();
        tranchePool = new TranchePool(address(usdt));
        
        // Configure tranches (matching Foundry)
        tranchePool.setMaxAllocationCapSeniorTranche(5_00_00_000 * USDT);
        tranchePool.setMaxAllocationCapJuniorTranche(3_00_00_000 * USDT);
        tranchePool.setMaxAllocationCapEquityTranche(2_00_00_000 * USDT);
        tranchePool.setMinimumDepositAmountSeniorTranche(10_00_000 * USDT);
        tranchePool.setMinimumDepositAmountJuniorTranche(50_00_000 * USDT);
        tranchePool.setMinimumDepositAmountEquityTranche(1_00_00_000 * USDT);
        tranchePool.setTrancheCapitalAllocationFactorJunior(15);
        tranchePool.setTrancheCapitalAllocationFactorSenior(80);
        tranchePool.setSeniorAPR(8);
        tranchePool.setTargetJuniorAPR(15);
        
        // Setup credit policy
        creditPolicy = new CreditPolicy();
        creditPolicy.setMaxTiers(3);
        creditPolicy.createPolicy(1);
        creditPolicy.updateEligibility(1, _createEligibilityCriteria());
        creditPolicy.updateRatios(1, _createFinancialRatios());
        creditPolicy.updateConcentration(1, _createConcentrationLimits());
        creditPolicy.updateAttestation(1, _createAttestationRequirements());
        creditPolicy.updateCovenants(1, _createMaintenanceCovenants());
        creditPolicy.setLoanTier(1, 1, _createMockTier("Tier 1"));
        creditPolicy.setPolicyDocument(1, keccak256(bytes("document")), "ipfs://policyDocHash");
        creditPolicy.freezePolicy(1);
        
        // Setup loan engine
        MockLoanProofVerifier mockVerifier = new MockLoanProofVerifier();
        loanEngine = new LoanEngine(
            address(creditPolicy),
            address(mockVerifier),
            500,
            address(tranchePool),
            address(usdt)
        );
        loanEngine.setMaxOriginationFeeBps(500);
        tranchePool.setLoanEngine(address(loanEngine));
        
        // Whitelist entities
        loanEngine.setWhitelistedFeeManager(feeManager, true);
        loanEngine.setWhitelistedOffRampingEntity(recevingEntity, true);
        loanEngine.setWhitelistedRepaymentAgent(recevingEntity, true);
        loanEngine.setWhitelistedRecoveryAgent(recevingEntity, true);
        
        // Create and fund users (matching Foundry - lots of users)
        for (uint160 i = 1; i < 100; i++) {
            seniorUsers.push(address(i));
            if (i % 2 == 0) {
                usdt.mint(address(i), 1_00_00_00000 * USDT);
                tranchePool.updateWhitelist(address(i), true);
            } else if (i % 3 == 0) {
                usdt.mint(address(i), 50_0000_0000 * USDT);
                tranchePool.updateWhitelist(address(i), true);
            } else {
                usdt.mint(address(i), 10_000_0000000 * USDT);
                tranchePool.updateWhitelist(address(i), true);
            }
        }
        
        for (uint160 i = 1; i < 10; i++) {
            juniorUsers.push(address(i));
            if (i % 2 == 0) {
                usdt.mint(address(i), 500000_00_000 * USDT);
                tranchePool.updateWhitelist(address(i), true);
            } else {
                usdt.mint(address(i), 10_000000_000 * USDT);
                tranchePool.updateWhitelist(address(i), true);
            }
        }
        
        for (uint160 i = 1; i < 5; i++) {
            equityUsers.push(address(i));
            usdt.mint(address(i), 50_0000_0000 * USDT);
            tranchePool.updateEquityTrancheWhiteList(address(i), true);
        }
        
        for (uint160 i = 200; i < 220; i++) {
            loanBorrowers.push(address(i));
        }
        
        usdt.mint(recevingEntity, 50_0000_0000 * USDT);
    }
    
    // =========================================================================
    // FUZZ FUNCTIONS - Matching Foundry Handler Logic
    // =========================================================================
    
    function depositSenior(uint256 userSeed, uint256 amount) external {
        if (tranchePool.getPoolState() != TranchePool.PoolState.OPEN) return;
        
        address user = seniorUsers[userSeed % seniorUsers.length];
        amount = _bound(
            amount,
            tranchePool.getSeniorTrancheMinimumDepositAmount(),
            tranchePool.getSeniorTrancheMaxDepositCap()
        );
        
        uint256 currentValue = tranchePool.getSeniorTrancheIdleValue() + 
                               tranchePool.getSeniorTrancheDeployedValue();
        
        if (currentValue >= tranchePool.getSeniorTrancheMaxDepositCap()) return;
        
        uint256 remaining = tranchePool.getSeniorTrancheMaxDepositCap() - currentValue;
        amount = _min(amount, remaining);
        
        if (amount < tranchePool.getSeniorTrancheMinimumDepositAmount()) return;
        if (amount == 0) return;
        
        _impersonate(user);
        usdt.approve(address(tranchePool), amount);
        tranchePool.depositSeniorTranche(amount);
        _stopImpersonate();
        
        totalIdleValue += amount;
    }
    
    function depositJunior(uint256 userSeed, uint256 amount) external {
        if (tranchePool.getPoolState() != TranchePool.PoolState.OPEN) return;
        
        address user = juniorUsers[userSeed % juniorUsers.length];
        amount = _bound(
            amount,
            tranchePool.getJuniorTrancheMinimumDepositAmount(),
            tranchePool.getJuniorTrancheMaxDepositCap()
        );
        
        uint256 currentValue = tranchePool.getJuniorTrancheIdleValue() + 
                               tranchePool.getJuniorTrancheDeployedValue();
        
        if (currentValue >= tranchePool.getJuniorTrancheMaxDepositCap()) return;
        
        uint256 remaining = tranchePool.getJuniorTrancheMaxDepositCap() - currentValue;
        amount = _min(amount, remaining);
        
        if (amount < tranchePool.getJuniorTrancheMinimumDepositAmount()) return;
        if (amount == 0) return;
        
        _impersonate(user);
        usdt.approve(address(tranchePool), amount);
        tranchePool.depositJuniorTranche(amount);
        _stopImpersonate();
        
        totalIdleValue += amount;
    }
    
    function depositEquity(uint256 userSeed, uint256 amount) external {
        if (tranchePool.getPoolState() != TranchePool.PoolState.OPEN) return;
        
        address user = equityUsers[userSeed % equityUsers.length];
        amount = _bound(
            amount,
            tranchePool.getEquityTrancheMinimumDepositAmount(),
            tranchePool.getEquityTrancheMaxDepositCap()
        );
        
        uint256 currentValue = tranchePool.getEquityTrancheIdleValue() + 
                               tranchePool.getEquityTrancheDeployedValue();
        
        if (currentValue >= tranchePool.getEquityTrancheMaxDepositCap()) return;
        
        uint256 remaining = tranchePool.getEquityTrancheMaxDepositCap() - currentValue;
        amount = _min(amount, remaining);
        
        if (amount < tranchePool.getEquityTrancheMinimumDepositAmount()) return;
        if (amount == 0) return;
        
        _impersonate(user);
        usdt.approve(address(tranchePool), amount);
        tranchePool.depositEquityTranche(amount);
        _stopImpersonate();
        
        totalIdleValue += amount;
    }
    
    function commitPool() external {
        if (tranchePool.getPoolState() == TranchePool.PoolState.OPEN && 
            tranchePool.getTotalIdleValue() > 0) {
            tranchePool.setPoolState(TranchePool.PoolState.COMMITED);
            totalDeposited = tranchePool.getTotalIdleValue();
        }
    }
    
    function createLoan(
        uint256 principalIssued,
        uint256 originationFeeBps,
        uint256 termDays,
        uint256 userIndex
    ) external {
        if (tranchePool.getPoolState() != TranchePool.PoolState.COMMITED &&
            tranchePool.getPoolState() != TranchePool.PoolState.DEPLOYED) return;
        
        // Matching Foundry handler logic
        uint256 minPrincipal = minimumLoanPrincipal;
        
        if (allowFullDeployment) {
            if (tranchePool.getTotalIdleValue() < minPrincipal) {
                minPrincipal = tranchePool.getTotalIdleValue();
            }
        } else {
            if (tranchePool.getTotalIdleValue() < minPrincipal * 10) {
                return;
            }
        }
        
        if (tranchePool.getTotalIdleValue() < minimumLoanPrincipal) return;
        
        principalIssued = _bound(
            principalIssued,
            minimumLoanPrincipal,
            _min(maximumLoanPrincipal, tranchePool.getTotalIdleValue())
        );
        
        if (principalIssued > tranchePool.getTotalIdleValue() / 10) {
            principalIssued = tranchePool.getTotalIdleValue() / 10;
        }
        
        originationFeeBps = _bound(
            originationFeeBps,
            minimumOriginationFeeBps,
            loanEngine.getMaxOriginationFeeBps()
        );
        
        termDays = _bound(termDays, minimumTermDays, maximumTermDays);
        
        if (!creditPolicy.isPolicyFrozen(activePolicyVersion)) return;
        
        bytes32 borrowerCommitment = keccak256(
            abi.encodePacked(
                loanBorrowers[userIndex % loanBorrowers.length],
                userIndex
            )
        );
        
        uint256 nextLoanId = loanEngine.getNextLoanId();
        bytes memory proofData = abi.encodePacked(
            nextLoanId,
            userIndex,
            principalIssued,
            originationFeeBps,
            termDays
        );
        
        loanEngine.createLoan(
            borrowerCommitment,
            keccak256(abi.encode(nextLoanId, userIndex, borrowerCommitment, block.timestamp)),
            activePolicyVersion,
            1,
            principalIssued,
            500,
            originationFeeBps,
            termDays,
            bytes32(0),
            proofData,
            new bytes32[](0)
        );
    }
    
    function activateLoan(uint256 loanId) external {
        if (loanEngine.getNextLoanId() == 1) return;
        
        loanId = _bound(loanId, 1, loanEngine.getNextLoanId() - 1);
        
        LoanEngine.Loan memory loan = loanEngine.getLoanDetails(loanId);
        if (loan.state != LoanEngine.LoanState.CREATED) return;
        
        if (tranchePool.getPoolState() != TranchePool.PoolState.COMMITED &&
            tranchePool.getPoolState() != TranchePool.PoolState.DEPLOYED) return;
        
        if (loan.principalIssued > tranchePool.getTotalIdleValue()) return;
        
        loanEngine.activateLoan(loanId, recevingEntity, feeManager);
        
        totalDeployedValue += loan.principalIssued;
        totalIdleValue -= loan.principalIssued;
        outStandingPrincipal += loan.principalIssued;
    }
    
    function repayLoan(uint256 loanId, uint256 principalAmount, uint256 interestAmount) external {
        if (loanEngine.getNextLoanId() == 1) return;
        
        loanId = _bound(loanId, 1, loanEngine.getNextLoanId() - 1);
        
        LoanEngine.Loan memory loanDetails = loanEngine.getLoanDetails(loanId);
        if (loanDetails.state != LoanEngine.LoanState.ACTIVE) return;
        
        principalAmount = _bound(principalAmount, 0, loanDetails.principalOutstanding);
        
        uint256 pendingInterest = _accrueInterest(loanId);
        uint256 totalInterestDue = loanDetails.interestAccrued + pendingInterest;
        
        interestAmount = _bound(interestAmount, 0, totalInterestDue);
        
        if (principalAmount == 0 && interestAmount == 0) return;
        
        // Interest before principal rule
        if (principalAmount > 0 && interestAmount == 0 && totalInterestDue > 0) return;
        
        uint256 totalRepayAmount = principalAmount + interestAmount;
        
        // Calculate ACTUAL amounts that will be paid (matching Foundry)
        uint256 interestAccrued = loanDetails.interestAccrued + _accrueInterest(loanId);
        uint256 actualInterestPaid = _min(totalRepayAmount, interestAccrued);
        uint256 actualPrincipalPaid = _min(
            totalRepayAmount - actualInterestPaid,
            loanDetails.principalOutstanding
        );
        
        _impersonate(recevingEntity);
        usdt.approve(address(loanEngine), totalRepayAmount);
        _stopImpersonate();
        
        totalUnclaimedInterest += actualInterestPaid;
        
        loanEngine.repayLoan(loanId, principalAmount, interestAmount, recevingEntity);
        
        // Use ACTUAL principal paid (THIS IS THE FIX!)
        totalDeployedValue -= actualPrincipalPaid;
        totalIdleValue += actualPrincipalPaid;
        outStandingPrincipal -= actualPrincipalPaid;
    }
    
    function warpTime(uint256 daysToWarp) external {
        daysToWarp = _bound(daysToWarp, 1, 365);
        vm.warp(block.timestamp + (daysToWarp * 1 days));
    }
    
    function maybeDeclareDefault(uint256 loanId, bytes32 reasonHash) external {
        if (loanEngine.getNextLoanId() == 1) return;
        
        defaultCounter++;
        if (defaultCounter % 10 != 0) return;
        
        loanId = _bound(loanId, 1, loanEngine.getNextLoanId() - 1);
        
        LoanEngine.Loan memory loan = loanEngine.getLoanDetails(loanId);
        if (loan.state != LoanEngine.LoanState.ACTIVE) return;
        
        loanEngine.declareDefault(loanId, reasonHash);
    }
    
    function maybeWriteOffLoan(uint256 loanId) external {
        if (loanEngine.getNextLoanId() == 1) return;
        
        writeOffCounter++;
        
        loanId = _bound(loanId, 1, loanEngine.getNextLoanId() - 1);
        
        if (loanEngine.getLoanDetails(loanId).state != LoanEngine.LoanState.DEFAULTED) return;
        
        // Read principal before writeoff
        uint256 principalOutstanding = loanEngine.getLoanDetails(loanId).principalOutstanding;
        
        loanEngine.writeOffLoan(loanId);
        
        totalDeployedValue -= principalOutstanding;
        outStandingPrincipal -= principalOutstanding;
        totalLoss += principalOutstanding;
    }
    
    function maybeRecoverLoan(uint256 loanId, uint256 amount, uint256 agentIndex) external {
        if (loanEngine.getNextLoanId() == 1) return;
        
        recoveryCounter++;
        
        loanId = _bound(loanId, 1, loanEngine.getNextLoanId() - 1);
        
        LoanEngine.Loan memory loan = loanEngine.getLoanDetails(loanId);
        if (loan.state != LoanEngine.LoanState.WRITTEN_OFF) return;
        
        amount = _bound(amount, 1, loan.principalIssued);
        
        _impersonate(recevingEntity);
        usdt.approve(address(loanEngine), amount);
        _stopImpersonate();
        
        loanEngine.recoverLoan(loanId, amount, recevingEntity);
        
        totalIdleValue += amount;
        totalRecovered += amount;
    }
    
    function mayClosePool() external {
        if (tranchePool.getTotalDeployedValue() > 0 || 
            tranchePool.getPoolState() != TranchePool.PoolState.DEPLOYED) return;
        
        tranchePool.setPoolState(TranchePool.PoolState.CLOSED);
    }
    
    // =========================================================================
    // INVARIANTS - Matching Foundry Invariants
    // =========================================================================
    
    function invariant_totalValueBalance() external view returns (bool) {
        return (tranchePool.getTotalIdleValue() + tranchePool.getTotalDeployedValue()) ==
               (tranchePool.getTotalDeposited() - tranchePool.getTotalLoss() + tranchePool.getTotalRecovered());
    }
    
    function invariant_deployedMatchesOutstanding() external view returns (bool) {
        return outStandingPrincipal == tranchePool.getTotalDeployedValue();
    }
    
    function invariant_principalIntegrity() external view returns (bool) {
        uint256 totalPrincipal = 0;
        uint256 nextId = loanEngine.getNextLoanId();
        
        for (uint256 i = 1; i < nextId; i++) {
            LoanEngine.Loan memory loan = loanEngine.getLoanDetails(i);
            totalPrincipal += loan.principalOutstanding;
        }
        
        return totalPrincipal == tranchePool.getTotalDeployedValue();
    }

    function invariant_tokenBalance() external view returns (bool) {
        return (tranchePool.getTotalUnclaimedInterest() + 
                tranchePool.getTotalIdleValue() + 
                tranchePool.getProtocolRevenue()) == 
                usdt.balanceOf(address(tranchePool));
    }

    function invariant_trancheSum() external view returns (bool) {
        return tranchePool.getTotalDeployedValue() == 
               (tranchePool.getSeniorTrancheDeployedValue() + 
                tranchePool.getJuniorTrancheDeployedValue() + 
                tranchePool.getEquityTrancheDeployedValue());
    }

    function invariant_waterfallSymmetry() external view returns (bool) {
        uint256 totalShortfall = tranchePool.getSeniorPrincipalShortfall() +
            tranchePool.getJuniorPrincipalShortfall() +
            tranchePool.getEquityPrincipalShortfall();

        if (tranchePool.getTotalRecovered() >= tranchePool.getTotalLoss()) {
            return totalShortfall == 0;
        } else {
            return totalShortfall == (tranchePool.getTotalLoss() - tranchePool.getTotalRecovered());
        }
    }

    function invariant_idleIntegrity() external view returns (bool) {
        return (tranchePool.getSeniorTrancheIdleValue() +
                tranchePool.getJuniorTrancheIdleValue() +
                tranchePool.getEquityTrancheIdleValue()) == 
                tranchePool.getTotalIdleValue();
    }

    function invariant_seniorShareOpen() external view returns (bool) {
        if (tranchePool.getPoolState() == TranchePool.PoolState.OPEN) {
            return tranchePool.getTotalSeniorShares() == tranchePool.getSeniorTrancheIdleValue();
        }
        return true;
    }

    function invariant_loanState() external view returns (bool) {
        uint256 nextId = loanEngine.getNextLoanId();
        for (uint256 i = 1; i < nextId; i++) {
            LoanEngine.Loan memory loan = loanEngine.getLoanDetails(i);
            
            if (loan.state == LoanEngine.LoanState.NONE || 
                loan.state == LoanEngine.LoanState.CREATED) {
                if (loan.principalOutstanding != 0) return false;
            }
            
            if (loan.state == LoanEngine.LoanState.REPAID ||
                loan.state == LoanEngine.LoanState.WRITTEN_OFF) {
                if (loan.principalOutstanding != 0) return false;
            }
            
            if (loan.state == LoanEngine.LoanState.ACTIVE) {
                if (loan.principalOutstanding > loan.principalIssued) return false;
            }
        }
        return true;
    }

    function invariant_interestMonotonicity() external view returns (bool) {
        return tranchePool.getSeniorInterestIndex() >= 1e18 &&
               tranchePool.getJuniorInterestIndex() >= 1e18 &&
               tranchePool.getEquityInterestIndex() >= 1e18;
    }

    function invariant_poolState() external view returns (bool) {
        TranchePool.PoolState state = tranchePool.getPoolState();
        if (state == TranchePool.PoolState.OPEN || 
            state == TranchePool.PoolState.CLOSED) {
            if (tranchePool.getTotalDeployedValue() != 0) return false;
        }
        return true;
    }

    function invariant_interestAccounting() external view returns (bool) {
        uint256 nextId = loanEngine.getNextLoanId();
        for (uint256 i = 1; i < nextId; i++) {
            LoanEngine.Loan memory loan = loanEngine.getLoanDetails(i);
            if (loan.state == LoanEngine.LoanState.REPAID) {
                if (loan.interestAccrued != 0) return false;
            }
            if (loan.state == LoanEngine.LoanState.WRITTEN_OFF) {
                if (loan.interestAccrued != 0) return false;
            }
        }
        return true;
    }
    
    // =========================================================================
    // HELPER FUNCTIONS
    // =========================================================================
    
    function _accrueInterest(uint256 loanId) internal view returns (uint256) {
        LoanEngine.Loan memory loan = loanEngine.getLoanDetails(loanId);
        
        uint256 timeElapsed = block.timestamp - loan.lastAccrualTimestamp;
        if (loan.principalOutstanding == 0) return 0;
        
        uint256 interest = (loan.principalOutstanding * loan.aprBps * timeElapsed) / (365 days * 10_000);
        return interest;
    }
    
    function _createEligibilityCriteria() internal pure returns (CreditPolicy.EligibilityCriteria memory) {
        return CreditPolicy.EligibilityCriteria({
            minAnnualRevenue: 1_00_00_000,
            minEBITDA: 10_00_000,
            minTangibleNetWorth: 5_00_00_000,
            minBusinessAgeDays: 180,
            maxDefaultsLast36Months: 0,
            bankruptcyExcluded: true
        });
    }
    
    function _createFinancialRatios() internal pure returns (CreditPolicy.FinancialRatios memory) {
        return CreditPolicy.FinancialRatios({
            maxTotalDebtToEBITDA: 4e18,
            minInterestCoverageRatio: 2e18,
            minCurrentRatio: 1e18,
            minEBITDAMarginBps: 1500
        });
    }
    
    function _createConcentrationLimits() internal pure returns (CreditPolicy.ConcentrationLimits memory) {
        return CreditPolicy.ConcentrationLimits({
            maxSingleBorrowerBps: 1000,
            maxIndustryConcentrationBps: 3000
        });
    }
    
    function _createAttestationRequirements() internal pure returns (CreditPolicy.AttestationRequirements memory) {
        return CreditPolicy.AttestationRequirements({
            maxAttestationAgeDays: 90,
            reAttestationFrequencyDays: 180,
            requiresCPAAttestation: true
        });
    }
    
    function _createMaintenanceCovenants() internal pure returns (CreditPolicy.MaintenanceCovenants memory) {
        return CreditPolicy.MaintenanceCovenants({
            maxLeverageRatio: 4e18,
            minCoverageRatio: 2e18,
            minLiquidityAmount: 1_00_00_000,
            allowsDividends: false,
            reportingFrequencyDays: 90
        });
    }
    
    function _createMockTier(string memory name) internal pure returns (CreditPolicy.LoanTier memory) {
        return CreditPolicy.LoanTier({
            name: name,
            minRevenue: 1_00_00_000,
            maxRevenue: 5_00_00_000,
            minEBITDA: 10_00_000,
            maxDebtToEBITDA: 3e18,
            maxLoanToEBITDA: 2e18,
            interestRateBps: 800,
            originationFeeBps: 100,
            termDays: 365,
            active: true
        });
    }
    
    function _bound(uint256 x, uint256 min, uint256 max) internal pure returns (uint256) {
        if (min > max) return min;
        if (x < min) return min;
        if (x > max) return max;
        return min + (x % (max - min + 1));
    }
    
    function _min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }
    
    // Medusa impersonate pattern
    function _impersonate(address who) internal {
        vm.startPrank(who);
    }
    
    function _stopImpersonate() internal {
        vm.stopPrank();
    }
}

// Hevm interface for cheatcodes
interface Hevm {
    function startPrank(address) external;
    function stopPrank() external;
    function warp(uint256) external;
}

100.0% test/mocks/MockLoanProofVerifier.sol

Lines covered: 2 / 2 (100.0%)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract MockLoanProofVerifier {
    function verify(
        bytes calldata proof,
        bytes32[] calldata publicInputs
    ) external pure returns (bool) {
        return true;
    }
}


1		// SPDX-License-Identifier: MIT
2		// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
3
4		pragma solidity ^0.8.20;
5
6		import {Context} from "../utils/Context.sol";
7
8		/**
9		* @dev Contract module which provides a basic access control mechanism, where
10		* there is an account (an owner) that can be granted exclusive access to
11		* specific functions.
12		*
13		* The initial owner is set to the address provided by the deployer. This can
14		* later be changed with {transferOwnership}.
15		*
16		* This module is used through inheritance. It will make available the modifier
17		* `onlyOwner`, which can be applied to your functions to restrict their use to
18		* the owner.
19		*/
20		abstract contract Ownable is Context {
21		address private _owner;
22
23		/**
24		* @dev The caller account is not authorized to perform an operation.
25		*/
26		error OwnableUnauthorizedAccount(address account);
27
28		/**
29		* @dev The owner is not a valid owner account. (eg. `address(0)`)
30		*/
31		error OwnableInvalidOwner(address owner);
32
33		event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
34
35		/**
36		* @dev Initializes the contract setting the address provided by the deployer as the initial owner.
37		*/
38		constructor(address initialOwner) {
39	✓ 1	if (initialOwner == address(0)) {
40		revert OwnableInvalidOwner(address(0));
41		}
42		_transferOwnership(initialOwner);
43		}
44
45		/**
46		* @dev Throws if called by any account other than the owner.
47		*/
48	✓ 82.9K	modifier onlyOwner() {
49		_checkOwner();
50		_;
51		}
52
53		/**
54		* @dev Returns the address of the current owner.
55		*/
56		function owner() public view virtual returns (address) {
57	✓ 135.5K	return _owner;
58		}
59
60		/**
61		* @dev Throws if the sender is not the owner.
62		*/
63		function _checkOwner() internal view virtual {
64	✓ 135.5K	if (owner() != _msgSender()) {
65		revert OwnableUnauthorizedAccount(_msgSender());
66		}
67		}
68
69		/**
70		* @dev Leaves the contract without owner. It will not be possible to call
71		* `onlyOwner` functions. Can only be called by the current owner.
72		*
73		* NOTE: Renouncing ownership will leave the contract without an owner,
74		* thereby disabling any functionality that is only available to the owner.
75		*/
76		function renounceOwnership() public virtual onlyOwner {
77		_transferOwnership(address(0));
78		}
79
80		/**
81		* @dev Transfers ownership of the contract to a new account (`newOwner`).
82		* Can only be called by the current owner.
83		*/
84		function transferOwnership(address newOwner) public virtual onlyOwner {
85		if (newOwner == address(0)) {
86		revert OwnableInvalidOwner(address(0));
87		}
88		_transferOwnership(newOwner);
89		}
90
91		/**
92		* @dev Transfers ownership of the contract to a new account (`newOwner`).
93		* Internal function without access restriction.
94		*/
95		function _transferOwnership(address newOwner) internal virtual {
96		address oldOwner = _owner;
97		_owner = newOwner;
98	✓ 1	emit OwnershipTransferred(oldOwner, newOwner);
99		}
100		}
101

1			// SPDX-License-Identifier: MIT
2			// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)
3
4			pragma solidity >=0.6.2;
5
6			import {IERC20} from "./IERC20.sol";
7			import {IERC165} from "./IERC165.sol";
8
9			/**
10			* @title IERC1363
11			* @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
12			*
13			* Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
14			* after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
15			*/
16			interface IERC1363 is IERC20, IERC165 {
17			/*
18			* Note: the ERC-165 identifier for this interface is 0xb0202a11.
19			* 0xb0202a11 ===
20			* bytes4(keccak256('transferAndCall(address,uint256)')) ^
21			* bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
22			* bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
23			* bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
24			* bytes4(keccak256('approveAndCall(address,uint256)')) ^
25			* bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
26			*/
27
28			/**
29			* @dev Moves a `value` amount of tokens from the caller's account to `to`
30			* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
31			* @param to The address which you want to transfer to.
32			* @param value The amount of tokens to be transferred.
33			* @return A boolean value indicating whether the operation succeeded unless throwing.
34			*/
35			function transferAndCall(address to, uint256 value) external returns (bool);
36
37			/**
38			* @dev Moves a `value` amount of tokens from the caller's account to `to`
39			* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
40			* @param to The address which you want to transfer to.
41			* @param value The amount of tokens to be transferred.
42			* @param data Additional data with no specified format, sent in call to `to`.
43			* @return A boolean value indicating whether the operation succeeded unless throwing.
44			*/
45			function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
46
47			/**
48			* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
49			* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
50			* @param from The address which you want to send tokens from.
51			* @param to The address which you want to transfer to.
52			* @param value The amount of tokens to be transferred.
53			* @return A boolean value indicating whether the operation succeeded unless throwing.
54			*/
55			function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
56
57			/**
58			* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
59			* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
60			* @param from The address which you want to send tokens from.
61			* @param to The address which you want to transfer to.
62			* @param value The amount of tokens to be transferred.
63			* @param data Additional data with no specified format, sent in call to `to`.
64			* @return A boolean value indicating whether the operation succeeded unless throwing.
65			*/
66			function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
67
68			/**
69			* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
70			* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
71			* @param spender The address which will spend the funds.
72			* @param value The amount of tokens to be spent.
73			* @return A boolean value indicating whether the operation succeeded unless throwing.
74			*/
75			function approveAndCall(address spender, uint256 value) external returns (bool);
76
77			/**
78			* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
79			* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
80			* @param spender The address which will spend the funds.
81			* @param value The amount of tokens to be spent.
82			* @param data Additional data with no specified format, sent in call to `spender`.
83			* @return A boolean value indicating whether the operation succeeded unless throwing.
84			*/
85			function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
86			}
87

1			// SPDX-License-Identifier: MIT
2			// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)
3
4			pragma solidity >=0.4.16;
5
6			import {IERC165} from "../utils/introspection/IERC165.sol";
7

1			// SPDX-License-Identifier: MIT
2			// OpenZeppelin Contracts (last updated v5.5.0) (interfaces/draft-IERC6093.sol)
3
4			pragma solidity >=0.8.4;
5
6			/**
7			* @dev Standard ERC-20 Errors
8			* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
9			*/
10			interface IERC20Errors {
11			/**
12			* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
13			* @param sender Address whose tokens are being transferred.
14			* @param balance Current balance for the interacting account.
15			* @param needed Minimum amount required to perform a transfer.
16			*/
17			error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
18
19			/**
20			* @dev Indicates a failure with the token `sender`. Used in transfers.
21			* @param sender Address whose tokens are being transferred.
22			*/
23			error ERC20InvalidSender(address sender);
24
25			/**
26			* @dev Indicates a failure with the token `receiver`. Used in transfers.
27			* @param receiver Address to which tokens are being transferred.
28			*/
29			error ERC20InvalidReceiver(address receiver);
30
31			/**
32			* @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
33			* @param spender Address that may be allowed to operate on tokens without being their owner.
34			* @param allowance Amount of tokens a `spender` is allowed to operate with.
35			* @param needed Minimum amount required to perform a transfer.
36			*/
37			error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
38
39			/**
40			* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
41			* @param approver Address initiating an approval operation.
42			*/
43			error ERC20InvalidApprover(address approver);
44
45			/**
46			* @dev Indicates a failure with the `spender` to be approved. Used in approvals.
47			* @param spender Address that may be allowed to operate on tokens without being their owner.
48			*/
49			error ERC20InvalidSpender(address spender);
50			}
51
52			/**
53			* @dev Standard ERC-721 Errors
54			* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
55			*/
56			interface IERC721Errors {
57			/**
58			* @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721.
59			* Used in balance queries.
60			* @param owner Address of the current owner of a token.
61			*/
62			error ERC721InvalidOwner(address owner);
63
64			/**
65			* @dev Indicates a `tokenId` whose `owner` is the zero address.
66			* @param tokenId Identifier number of a token.
67			*/
68			error ERC721NonexistentToken(uint256 tokenId);
69
70			/**
71			* @dev Indicates an error related to the ownership over a particular token. Used in transfers.
72			* @param sender Address whose tokens are being transferred.
73			* @param tokenId Identifier number of a token.
74			* @param owner Address of the current owner of a token.
75			*/
76			error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
77
78			/**
79			* @dev Indicates a failure with the token `sender`. Used in transfers.
80			* @param sender Address whose tokens are being transferred.
81			*/
82			error ERC721InvalidSender(address sender);
83
84			/**
85			* @dev Indicates a failure with the token `receiver`. Used in transfers.
86			* @param receiver Address to which tokens are being transferred.
87			*/
88			error ERC721InvalidReceiver(address receiver);
89
90			/**
91			* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
92			* @param operator Address that may be allowed to operate on tokens without being their owner.
93			* @param tokenId Identifier number of a token.
94			*/
95			error ERC721InsufficientApproval(address operator, uint256 tokenId);
96
97			/**
98			* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
99			* @param approver Address initiating an approval operation.
100			*/
101			error ERC721InvalidApprover(address approver);
102
103			/**
104			* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
105			* @param operator Address that may be allowed to operate on tokens without being their owner.
106			*/
107			error ERC721InvalidOperator(address operator);
108			}
109
110			/**
111			* @dev Standard ERC-1155 Errors
112			* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
113			*/
114			interface IERC1155Errors {
115			/**
116			* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
117			* @param sender Address whose tokens are being transferred.
118			* @param balance Current balance for the interacting account.
119			* @param needed Minimum amount required to perform a transfer.
120			* @param tokenId Identifier number of a token.
121			*/
122			error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
123
124			/**
125			* @dev Indicates a failure with the token `sender`. Used in transfers.
126			* @param sender Address whose tokens are being transferred.
127			*/
128			error ERC1155InvalidSender(address sender);
129
130			/**
131			* @dev Indicates a failure with the token `receiver`. Used in transfers.
132			* @param receiver Address to which tokens are being transferred.
133			*/
134			error ERC1155InvalidReceiver(address receiver);
135
136			/**
137			* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
138			* @param operator Address that may be allowed to operate on tokens without being their owner.
139			* @param owner Address of the current owner of a token.
140			*/
141			error ERC1155MissingApprovalForAll(address operator, address owner);
142
143			/**
144			* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
145			* @param approver Address initiating an approval operation.
146			*/
147			error ERC1155InvalidApprover(address approver);
148
149			/**
150			* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
151			* @param operator Address that may be allowed to operate on tokens without being their owner.
152			*/
153			error ERC1155InvalidOperator(address operator);
154
155			/**
156			* @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
157			* Used in batch transfers.
158			* @param idsLength Length of the array of token identifiers
159			* @param valuesLength Length of the array of token amounts
160			*/
161			error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
162			}
163

1		// SPDX-License-Identifier: MIT
2		pragma solidity ^0.8.20;
3
4		import {ERC20} from "../../token/ERC20/ERC20.sol";
5
6	✓ 239.3K	contract ERC20Mock is ERC20 {
7		constructor() ERC20("ERC20Mock", "E20M") {}
8
9		function mint(address account, uint256 amount) external {
10		_mint(account, amount);
11		}
12
13		function burn(address account, uint256 amount) external {
14		_burn(account, amount);
15		}
16		}
17

1		// SPDX-License-Identifier: MIT
2		// OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)
3		// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
4
5		pragma solidity ^0.8.20;
6
7		/**
8		* @dev Library for reading and writing primitive types to specific storage slots.
9		*
10		* Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
11		* This library helps with reading and writing to such slots without the need for inline assembly.
12		*
13		* The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
14		*
15		* Example usage to set ERC-1967 implementation slot:
16		* ```solidity
17		* contract ERC1967 {
18		* // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.
19		* bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
20		*
21		* function _getImplementation() internal view returns (address) {
22		* return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
23		* }
24		*
25		* function _setImplementation(address newImplementation) internal {
26		* require(newImplementation.code.length > 0);
27		* StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
28		* }
29		* }
30		* ```
31		*
32		* TIP: Consider using this library along with {SlotDerivation}.
33		*/
34	✓ 2	library StorageSlot {
35		struct AddressSlot {
36		address value;
37		}
38
39		struct BooleanSlot {
40		bool value;
41		}
42
43		struct Bytes32Slot {
44		bytes32 value;
45		}
46
47		struct Uint256Slot {
48		uint256 value;
49		}
50
51		struct Int256Slot {
52		int256 value;
53		}
54
55		struct StringSlot {
56		string value;
57		}
58
59		struct BytesSlot {
60		bytes value;
61		}
62
63		/**
64		* @dev Returns an `AddressSlot` with member `value` located at `slot`.
65		*/
66		function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
67		assembly ("memory-safe") {
68		r.slot := slot
69		}
70		}
71
72		/**
73		* @dev Returns a `BooleanSlot` with member `value` located at `slot`.
74		*/
75		function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
76		assembly ("memory-safe") {
77		r.slot := slot
78		}
79		}
80
81		/**
82		* @dev Returns a `Bytes32Slot` with member `value` located at `slot`.
83		*/
84		function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
85		assembly ("memory-safe") {
86		r.slot := slot
87		}
88		}
89
90		/**
91		* @dev Returns a `Uint256Slot` with member `value` located at `slot`.
92		*/
93		function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
94		assembly ("memory-safe") {
95		r.slot := slot
96		}
97		}
98
99		/**
100		* @dev Returns a `Int256Slot` with member `value` located at `slot`.
101		*/
102		function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {
103		assembly ("memory-safe") {
104		r.slot := slot
105		}
106		}
107
108		/**
109		* @dev Returns a `StringSlot` with member `value` located at `slot`.
110		*/
111		function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
112		assembly ("memory-safe") {
113		r.slot := slot
114		}
115		}
116
117		/**
118		* @dev Returns an `StringSlot` representation of the string storage pointer `store`.
119		*/
120		function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
121		assembly ("memory-safe") {
122		r.slot := store.slot
123		}
124		}
125
126		/**
127		* @dev Returns a `BytesSlot` with member `value` located at `slot`.
128		*/
129		function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
130		assembly ("memory-safe") {
131		r.slot := slot
132		}
133		}
134
135		/**
136		* @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
137		*/
138		function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
139		assembly ("memory-safe") {
140		r.slot := store.slot
141		}
142		}
143		}
144

1		// SPDX-License-Identifier: MIT
2		pragma solidity ^0.8.24;
3		import {ICreditPolicy} from "./interfaces/ICreditPolicy.sol";
4
5
6		/**
7		* @title CreditPolicy
8		* @notice Immutable-by-version credit constitution for private credit funds
9		*/
10		contract CreditPolicy is ICreditPolicy {
11		/*//////////////////////////////////////////////////////////////
12		ERRORS
13		//////////////////////////////////////////////////////////////*/
14		error CreditPolicy__Unauthorized();
15		error CreditPolicy__PolicyFrozen(uint256 version);
16		error CreditPolicy__InvalidVersion();
17		error CreditPolicy__PolicyVersionExists(uint256 version);
18		error CreditPolicy__InvalidAdmin();
19		error CreditPolicy__PolicyNotEditable(uint256 version);
20		error CreditPolicy__IncompletePolicy(uint256 version);
21		error CreditPolicy__InvalidIndustryHash();
22		error CreditPolicy__PolicyNotActive(uint256 version);
23		error CreditPolicy__InvalidTierCount(uint256 count);
24		/*//////////////////////////////////////////////////////////////
25		MODIFIERS
26		//////////////////////////////////////////////////////////////*/
27	✓ 1	modifier onlyAdmin() {
28		_onlyAdmin();
29		_;
30		}
31
32		function _onlyAdmin() internal view {
33	✓ 10	if (msg.sender != policyAdmin) revert CreditPolicy__Unauthorized();
34		}
35
36		modifier policyEditable(uint256 version) {
37	✓ 1	_policyEditable(version);
38		_;
39		}
40
41		function _policyEditable(uint256 version) internal view {
42	✓ 7	if (policyFrozen[version] \|\| !policyActive[version])
43		revert CreditPolicy__PolicyNotEditable(version);
44		}
45
46		modifier policyExists(uint256 version) {
47	✓ 1	_policyExists(version);
48		_;
49		}
50
51		function _policyExists(uint256 version) internal view {
52	✓ 8	if (!policyCreated[version]) revert CreditPolicy__InvalidVersion();
53		}
54
55		/*//////////////////////////////////////////////////////////////
56		CORE ROLES
57		//////////////////////////////////////////////////////////////*/
58		address public policyAdmin;
59		uint8 internal maxTiers;
60
61		/*//////////////////////////////////////////////////////////////
62		POLICY LIFECYCLE
63		//////////////////////////////////////////////////////////////*/
64		mapping(uint256 => bool) public policyCreated;
65	✓ 165.9K	mapping(uint256 => bool) public policyFrozen;
66		mapping(uint256 => bool) public policyActive;
67		mapping(uint256 => uint256) public lastUpdated;
68
69		/*//////////////////////////////////////////////////////////////
70		ELIGIBILITY (PRE-LOAN)
71		//////////////////////////////////////////////////////////////*/
72		struct EligibilityCriteria {
73		uint256 minAnnualRevenue;
74		uint256 minEBITDA;
75		uint256 minTangibleNetWorth;
76		uint256 minBusinessAgeDays;
77		uint256 maxDefaultsLast36Months;
78		bool bankruptcyExcluded;
79		}
80
81		mapping(uint256 => EligibilityCriteria) public eligibility;
82
83		/*//////////////////////////////////////////////////////////////
84		FINANCIAL RATIOS (UNDERWRITING)
85		//////////////////////////////////////////////////////////////*/
86		struct FinancialRatios {
87		uint256 maxTotalDebtToEBITDA;
88		uint256 minInterestCoverageRatio;
89		uint256 minCurrentRatio;
90		uint256 minEBITDAMarginBps;
91		}
92
93		mapping(uint256 => FinancialRatios) public ratios;
94
95		/*//////////////////////////////////////////////////////////////
96		LOAN TIERS (PRICING REFERENCE)
97		//////////////////////////////////////////////////////////////*/
98		struct LoanTier {
99		string name;
100		uint256 minRevenue;
101		uint256 maxRevenue;
102		uint256 minEBITDA;
103		uint256 maxDebtToEBITDA;
104		uint256 maxLoanToEBITDA;
105		uint256 interestRateBps;
106		uint256 originationFeeBps;
107		uint256 termDays;
108		bool active;
109		}
110
111		mapping(uint256 => mapping(uint8 => LoanTier)) public loanTiers;
112		mapping(uint256 => uint8) public totalTiers;
113	✓ 82.9K	mapping(uint256 => mapping(uint8 => bool)) public tierExists;
114
115		/*//////////////////////////////////////////////////////////////
116		CONCENTRATION LIMITS
117		//////////////////////////////////////////////////////////////*/
118		struct ConcentrationLimits {
119		uint256 maxSingleBorrowerBps;
120		uint256 maxIndustryConcentrationBps;
121		}
122
123		mapping(uint256 => ConcentrationLimits) public concentration;
124
125		/*//////////////////////////////////////////////////////////////
126		INDUSTRY EXCLUSIONS
127		//////////////////////////////////////////////////////////////*/
128		mapping(uint256 => mapping(bytes32 => bool)) public excludedIndustries;
129
130		/*//////////////////////////////////////////////////////////////
131		ATTESTATION REQUIREMENTS
132		//////////////////////////////////////////////////////////////*/
133		struct AttestationRequirements {
134		uint256 maxAttestationAgeDays;
135		uint256 reAttestationFrequencyDays;
136		bool requiresCPAAttestation;
137		}
138
139		mapping(uint256 => AttestationRequirements) public attestation;
140
141		/*//////////////////////////////////////////////////////////////
142		MAINTENANCE COVENANTS
143		//////////////////////////////////////////////////////////////*/
144		struct MaintenanceCovenants {
145		uint256 maxLeverageRatio;
146		uint256 minCoverageRatio;
147		uint256 minLiquidityAmount;
148		bool allowsDividends;
149		uint256 reportingFrequencyDays;
150		}
151
152		mapping(uint256 => MaintenanceCovenants) public covenants;
153
154		/*//////////////////////////////////////////////////////////////
155		DOCUMENT ANCHORING
156		//////////////////////////////////////////////////////////////*/
157		mapping(uint256 => bytes32) public policyDocumentHash;
158		mapping(uint256 => string) public policyDocumentURI;
159
160		mapping(uint256 => bool) public eligibilitySet;
161		mapping(uint256 => bool) public ratiosSet;
162		mapping(uint256 => bool) public concentrationSet;
163		mapping(uint256 => bool) public attestationSet;
164		mapping(uint256 => bool) public covenantsSet;
165		mapping(uint256 => bool) public hasAtLeastOneTier;
166
167		/*//////////////////////////////////////////////////////////////
168		EVENTS
169		//////////////////////////////////////////////////////////////*/
170		event PolicyCreated(uint256 version, uint256 timestamp);
171		event PolicyFrozen(uint256 version, uint256 timestamp);
172		event PolicyEligibilityUpdated(uint256 version, uint256 timestamp);
173		event PolicyRatiosUpdated(uint256 version, uint256 timestamp);
174		event PolicyConcentrationUpdated(uint256 version, uint256 timestamp);
175		event PolicyAttestationUpdated(uint256 version, uint256 timestamp);
176		event PolicyCovenantsUpdated(uint256 version, uint256 timestamp);
177		event LoanTierUpdated(uint256 version, uint8 tierId, uint256 timestamp);
178		event IndustryExcluded(
179		uint256 version,
180		bytes32 industry,
181		uint256 timestamp
182		);
183		event MaxTiersChanged(uint8 maxTiers);
184		event IndustryIncluded(
185		uint256 version,
186		bytes32 industry,
187		uint256 timestamp
188		);
189
190		event PolicyAdminChanged(address newAdmin);
191
192		event PolicyDocumentSet(
193		uint256 version,
194		bytes32 hash,
195		string uri,
196		uint256 timestamp
197		);
198		event PolicyDeactivated(uint256 version, uint256 timestamp);
199
200		/*//////////////////////////////////////////////////////////////
201		CONSTRUCTOR
202		//////////////////////////////////////////////////////////////*/
203		constructor() {
204	✓ 1	policyAdmin = msg.sender;
205		}
206
207		/*//////////////////////////////////////////////////////////////
208		POLICY CREATION
209		//////////////////////////////////////////////////////////////*/
210
211		function createPolicy(uint256 version) external onlyAdmin {
212	✓ 1	if (version == 0) {
213		revert CreditPolicy__InvalidVersion();
214		}
215		if (policyCreated[version]) {
216		revert CreditPolicy__PolicyVersionExists(version);
217		}
218
219		policyCreated[version] = true;
220	✓ 1	policyActive[version] = true;
221	✓ 1	lastUpdated[version] = block.timestamp;
222	✓ 1	emit PolicyCreated(version, block.timestamp);
223		}
224
225		function freezePolicy(
226		uint256 version
227		) external onlyAdmin policyExists(version) {
228	✓ 1	if (policyFrozen[version]) {
229		revert CreditPolicy__PolicyFrozen(version);
230		}
231	✓ 1	if (policyActive[version] == false) {
232		revert CreditPolicy__PolicyNotActive(version);
233		}
234		if (
235	✓ 1	!eligibilitySet[version] \|\|
236	✓ 1	!ratiosSet[version] \|\|
237	✓ 1	!concentrationSet[version] \|\|
238	✓ 1	!attestationSet[version] \|\|
239	✓ 1	!covenantsSet[version] \|\|
240	✓ 1	!hasAtLeastOneTier[version]
241		) {
242		revert CreditPolicy__IncompletePolicy(version);
243		}
244	✓ 1	if (policyDocumentHash[version] == bytes32(0)) {
245		revert CreditPolicy__IncompletePolicy(version);
246		}
247
248		policyFrozen[version] = true;
249	✓ 1	lastUpdated[version] = block.timestamp;
250	✓ 1	emit PolicyFrozen(version, block.timestamp);
251		}
252
253		function deActivatePolicy(
254		uint256 version
255		) external onlyAdmin policyExists(version) {
256		policyActive[version] = false;
257		lastUpdated[version] = block.timestamp;
258		emit PolicyDeactivated(version, block.timestamp);
259		}
260
261		/*//////////////////////////////////////////////////////////////
262		ELIGIBILITY UPDATE
263		//////////////////////////////////////////////////////////////*/
264		function updateEligibility(
265		uint256 version,
266		EligibilityCriteria calldata data
267		) external onlyAdmin policyExists(version) policyEditable(version) {
268	✓ 1	eligibility[version] = data;
269	✓ 1	lastUpdated[version] = block.timestamp;
270	✓ 1	eligibilitySet[version] = true;
271	✓ 1	emit PolicyEligibilityUpdated(version, block.timestamp);
272		}
273
274		/*//////////////////////////////////////////////////////////////
275		RATIOS UPDATE
276		//////////////////////////////////////////////////////////////*/
277		function updateRatios(
278		uint256 version,
279		FinancialRatios calldata data
280		) external onlyAdmin policyExists(version) policyEditable(version) {
281	✓ 1	ratios[version] = data;
282	✓ 1	lastUpdated[version] = block.timestamp;
283	✓ 1	ratiosSet[version] = true;
284	✓ 1	emit PolicyRatiosUpdated(version, block.timestamp);
285		}
286
287		/*//////////////////////////////////////////////////////////////
288		CONCENTRATION UPDATE
289		//////////////////////////////////////////////////////////////*/
290		function updateConcentration(
291		uint256 version,
292		ConcentrationLimits calldata data
293		) external onlyAdmin policyExists(version) policyEditable(version) {
294	✓ 1	concentration[version] = data;
295	✓ 1	lastUpdated[version] = block.timestamp;
296	✓ 1	concentrationSet[version] = true;
297	✓ 1	emit PolicyConcentrationUpdated(version, block.timestamp);
298		}
299
300		/*//////////////////////////////////////////////////////////////
301		ATTESTATION UPDATE
302		//////////////////////////////////////////////////////////////*/
303		function updateAttestation(
304		uint256 version,
305		AttestationRequirements calldata data
306		) external onlyAdmin policyExists(version) policyEditable(version) {
307	✓ 1	attestation[version] = data;
308	✓ 1	lastUpdated[version] = block.timestamp;
309	✓ 1	attestationSet[version] = true;
310	✓ 1	emit PolicyAttestationUpdated(version, block.timestamp);
311		}
312
313		/*//////////////////////////////////////////////////////////////
314		COVENANT UPDATE
315		//////////////////////////////////////////////////////////////*/
316		function updateCovenants(
317		uint256 version,
318		MaintenanceCovenants calldata data
319		) external onlyAdmin policyExists(version) policyEditable(version) {
320	✓ 1	covenants[version] = data;
321	✓ 1	lastUpdated[version] = block.timestamp;
322	✓ 1	covenantsSet[version] = true;
323	✓ 1	emit PolicyCovenantsUpdated(version, block.timestamp);
324		}
325
326		/*//////////////////////////////////////////////////////////////
327		LOAN TIERS
328		//////////////////////////////////////////////////////////////*/
329		function setLoanTier(
330		uint256 version,
331		uint8 tierId,
332		LoanTier calldata tier
333		) external onlyAdmin policyExists(version) policyEditable(version) {
334	✓ 1	if (tierId >= maxTiers) {
335		revert CreditPolicy__InvalidTierCount(tierId);
336		}
337	✓ 1	loanTiers[version][tierId] = tier;
338		tierExists[version][tierId] = true;
339	✓ 1	if (tierId >= totalTiers[version]) {
340		totalTiers[version] = tierId + 1;
341		}
342	✓ 1	hasAtLeastOneTier[version] = true;
343	✓ 1	lastUpdated[version] = block.timestamp;
344	✓ 1	emit LoanTierUpdated(version, tierId, block.timestamp);
345		}
346
347		/*//////////////////////////////////////////////////////////////
348		INDUSTRY CONTROLS
349		//////////////////////////////////////////////////////////////*/
350		function excludeIndustry(
351		uint256 version,
352		bytes32 industry
353		) external onlyAdmin policyExists(version) policyEditable(version) {
354		if (industry == bytes32(0)) {
355		revert CreditPolicy__InvalidIndustryHash();
356		}
357		excludedIndustries[version][industry] = true;
358		lastUpdated[version] = block.timestamp;
359		emit IndustryExcluded(version, industry, block.timestamp);
360		}
361
362		function includeIndustry(
363		uint256 version,
364		bytes32 industry
365		) external onlyAdmin policyExists(version) policyEditable(version) {
366		if (industry == bytes32(0)) {
367		revert CreditPolicy__InvalidIndustryHash();
368		}
369		excludedIndustries[version][industry] = false;
370		lastUpdated[version] = block.timestamp;
371		emit IndustryIncluded(version, industry, block.timestamp);
372		}
373
374		/*//////////////////////////////////////////////////////////////
375		DOCUMENT UPDATE
376		//////////////////////////////////////////////////////////////*/
377		function setPolicyDocument(
378		uint256 version,
379		bytes32 hash,
380		string calldata uri
381		) external onlyAdmin policyExists(version) policyEditable(version) {
382	✓ 1	policyDocumentHash[version] = hash;
383	✓ 1	policyDocumentURI[version] = uri;
384	✓ 1	lastUpdated[version] = block.timestamp;
385
386	✓ 1	emit PolicyDocumentSet(version, hash, uri, block.timestamp);
387		}
388
389		function changePolicyAdmin(address newAdmin) external onlyAdmin {
390		if (newAdmin == address(0)) {
391		revert CreditPolicy__InvalidAdmin();
392		}
393		policyAdmin = newAdmin;
394
395		emit PolicyAdminChanged(newAdmin);
396		}
397
398		// getters for interface compliance
399
400		function isPolicyActive(uint256 version) external view returns (bool) {
401		return policyActive[version];
402		}
403
404		function isPolicyFrozen(uint256 version) external view returns (bool) {
405		return policyFrozen[version];
406		}
407
408		function tierExistsInPolicy(
409		uint256 version,
410		uint8 tierId
411		) external view returns (bool) {
412		return tierExists[version][tierId];
413		}
414
415		function setMaxTiers(uint8 _maxTiers) external onlyAdmin {
416	✓ 1	if (_maxTiers == 255) {
417		revert CreditPolicy__InvalidTierCount(_maxTiers);
418		}
419		maxTiers = _maxTiers;
420	✓ 1	emit MaxTiersChanged(_maxTiers);
421		}
422
423		function getMaxTiers() external view returns (uint8) {
424		return maxTiers;
425		}
426
427		function isIndustryExcluded(
428		uint256 version,
429		bytes32 industry
430		) external view returns (bool) {
431	✓ 82.9K	return excludedIndustries[version][industry];
432		}
433		}
434

1		// SPDX-License-Identifier: MIT
2		pragma solidity ^0.8.24;
3
4		import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
5		import {ICreditPolicy} from "./interfaces/ICreditPolicy.sol";
6		import {IVerifier} from "./interfaces/IVerifier.sol";
7		import {ITranchePool} from "./interfaces/ITranchePool.sol";
8		import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
9		import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
10		import {TranchePool} from "./TranchePool.sol";
11
12		contract LoanEngine is Ownable, ReentrancyGuard {
13		using SafeERC20 for IERC20;
14		/*//////////////////////////////////////////////////////////////
15		ERRORS
16		//////////////////////////////////////////////////////////////*/
17
18		error LoanEngine__PolicyNotFrozen(uint256 policyVersion);
19		error LoanEngine__InvalidProof();
20		error LoanEngine__LoanTierIsNotInPolicy(
21		uint256 policyVersion,
22		uint8 tierId
23		);
24		error LoanEngine__InvalidLoanParameters(
25		uint256 loanId,
26		uint256 principalIssued,
27		uint256 aprBps,
28		uint256 termDays
29		);
30		error LoanEngine__MaxOriginationFeeExceeded(
31		uint256 loanId,
32		uint256 originationFeeBps,
33		uint256 maxOriginationFeeBps
34		);
35		error LoanEngine__PoolNotDeployed();
36		error LoanEngine__InvalidOffRampingEntity(address entity);
37		error LoanEngine__LoanExists(uint256 loanId);
38		error LoanEngine__LoanIsNotInCreatedState(uint256 loanId);
39		error LoanEngine__LoanIsNotActive(uint256 loanId);
40		error LoanEngine__LoanIsNotDefaulted(uint256 loanId);
41		error LoanEngine__InvalidRepayment();
42		error LoanEngine__ZeroRecovery();
43		error LoanEngine__LoanNotRecoverable(uint256 loanId);
44		error LoanEngine__ZeroLossOnWriteOff(uint256 loanId);
45		error LoanEngine__InvalidFeeManagerEntity(address manager);
46		error LoanEngine__InvalidRecoveryAgent(address agent);
47		error LoanEngine__InvalidRepaymentAgent(address agent);
48		error LoanEngine__InsufficientPoolLiquidity();
49		error LoanEngine__ProofAlreadyUsed();
50		modifier isWhiteListedOffRampingEntity(address entity) {
51		_isWhiteListedOffRampingEntity(entity);
52		_;
53		}
54
55		function _isWhiteListedOffRampingEntity(address entity) internal view {
56	✓ 35.3K	if (!whitelistedOffRampingEntities[entity]) {
57		revert LoanEngine__InvalidOffRampingEntity(entity);
58		}
59		}
60
61		modifier isWhiteListedRecoveryAgent(address agent) {
62		_isWhiteListedRecoveryAgent(agent);
63		_;
64		}
65
66		function _isWhiteListedRecoveryAgent(address agent) internal view {
67		if (!whitelistedRecoveryAgents[agent]) {
68		revert LoanEngine__InvalidRecoveryAgent(agent);
69		}
70		}
71
72		modifier isWhiteListedRepaymentAgent(address agent) {
73		_isWhiteListedRepaymentAgent(agent);
74		_;
75		}
76
77		function _isWhiteListedRepaymentAgent(address agent) internal view {
78	✓ 17.2K	if (!whitelistedRepaymentAgents[agent]) {
79		revert LoanEngine__InvalidRepaymentAgent(agent);
80		}
81		}
82
83		modifier isWhiteListedFeeManager(address manager) {
84		_isWhiteListedFeeManager(manager);
85		_;
86		}
87
88		function _isWhiteListedFeeManager(address manager) internal view {
89	✓ 35.3K	if (!whitelistedFeeManagers[manager]) {
90		revert LoanEngine__InvalidFeeManagerEntity(manager);
91		}
92		}
93
94		ICreditPolicy public creditPolicyContract;
95		IVerifier loanProofVerifier;
96		ITranchePool tranchePool;
97
98		mapping(uint256 loanId => Loan) public s_loans;
99		mapping(uint256 loanId => uint256) public s_originationFees;
100		mapping(address whitelistedOffRampingEntity => bool)
101		public whitelistedOffRampingEntities;
102		mapping(address whiteListedRecoveryAgent => bool)
103		public whitelistedRecoveryAgents;
104
105		mapping(address whiteListedRepaymentAgent => bool)
106		public whitelistedRepaymentAgents;
107
108		mapping(address whiteListedFeeManager => bool)
109		public whitelistedFeeManagers;
110		mapping(bytes32 nullifierHash => bool) public s_nullifierHashes;
111	✓ 1	uint256 public s_nextLoanId = 1;
112	✓ 82.9K	uint256 public s_maxOriginationFeeBps;
113		address public s_stableCoinAddress;
114		uint256 public constant STANDARD_BPS = 100;
115		enum LoanState {
116		NONE,
117		CREATED,
118		ACTIVE,
119		REPAID,
120		DEFAULTED,
121		WRITTEN_OFF
122		}
123
124		struct Loan {
125		// Identity
126		uint256 loanId;
127		bytes32 borrowerCommitment;
128		uint256 policyVersion;
129		uint8 tierId;
130		// Economics
131		uint256 principalIssued;
132		uint256 principalOutstanding;
133		uint256 aprBps;
134		uint256 originationFeeBps;
135		// Interest accounting
136		uint256 interestAccrued;
137		uint256 interestPaid;
138		uint256 lastAccrualTimestamp;
139		// Timing
140		uint256 startTimestamp;
141		uint256 maturityTimestamp;
142		uint256 termDays;
143		// State
144		LoanState state;
145		uint256 totalRecovered;
146		// allocation_ratio
147		uint256 seniorPrincipalAllocated;
148		uint256 juniorPrincipalAllocated;
149		}
150
151		/*//////////////////////////////////////////////////////////////
152		EVENTS
153		//////////////////////////////////////////////////////////////*/
154
155		event LoanCreated(
156		uint256 indexed loanId,
157		bytes32 borrowerCommitment,
158		uint256 principalIssued,
159		uint8 tierId,
160		uint256 timestamp
161		);
162
163		event LoanActivated(
164		uint256 indexed loanId,
165		uint256 principalIssued,
166		uint256 timestamp,
167		uint256 startTimestamp,
168		uint256 maturityTimestamp
169		);
170
171		event LoanRepaid(
172		uint256 indexed loanId,
173		uint256 principalRepaid,
174		uint256 interestRepaid,
175		uint256 timestamp
176		);
177
178		event LoanClosed(uint256 indexed loanId, uint256 timestamp);
179
180		event LoanDefaulted(
181		uint256 indexed loanId,
182		bytes32 reasonHash,
183		uint256 timestamp
184		);
185
186		event LoanWrittenOff(uint256 indexed loanId, uint256 timestamp);
187
188		event LoanRecovered(
189		uint256 indexed loanId,
190		uint256 amount,
191		uint256 timestamp
192		);
193
194		constructor(
195		address _creditPolicyContract,
196		address _loanProofVerifier,
197		uint256 _maxOriginationFeeBps,
198		address _tranchePool,
199		address _stableCoinAddress
200	✓ 1	) Ownable(msg.sender) {
201		creditPolicyContract = ICreditPolicy(_creditPolicyContract);
202	✓ 1	loanProofVerifier = IVerifier(_loanProofVerifier);
203	✓ 1	s_maxOriginationFeeBps = _maxOriginationFeeBps;
204	✓ 1	tranchePool = ITranchePool(_tranchePool);
205	✓ 1	s_stableCoinAddress = _stableCoinAddress;
206		}
207
208		// A notarization step that records a policy-compliant loan intent on-chain
209		// TODO: public inputs needed to be verified against the contract state
210		// will be implemented after the public inputs structure is finalized
211		// preconditions
212		// borrowerCommitment should match the publicinput commitment
213		// all the parameteres should match the public inputs
214		function createLoan(
215		bytes32 borrowerCommitment,
216		bytes32 nullifierHash,
217		uint256 policyVersion,
218		uint8 tierId,
219		uint256 principalIssued,
220		uint256 aprBps,
221		uint256 originationFeeBps,
222		uint256 termDays,
223		bytes32 industry,
224		bytes calldata proofData,
225		bytes32[] calldata publicInputs
226		) external onlyOwner {
227	✓ 82.9K	if (s_loans[s_nextLoanId].state != LoanState.NONE) {
228		revert LoanEngine__LoanExists(s_nextLoanId);
229		}
230		// Implementation goes here
231	✓ 82.9K	if (!creditPolicyContract.isPolicyFrozen(policyVersion)) {
232		revert LoanEngine__PolicyNotFrozen(policyVersion);
233		}
234
235	✓ 82.9K	if (creditPolicyContract.isIndustryExcluded(policyVersion, industry)) {
236		revert LoanEngine__PolicyNotFrozen(policyVersion);
237		}
238
239	✓ 82.9K	if (!creditPolicyContract.tierExistsInPolicy(policyVersion, tierId)) {
240		revert LoanEngine__LoanTierIsNotInPolicy(policyVersion, tierId);
241		}
242
243	✓ 82.9K	if (s_nullifierHashes[nullifierHash]) {
244		revert LoanEngine__ProofAlreadyUsed();
245		}
246
247	✓ 82.9K	if (loanProofVerifier.verify(proofData, publicInputs) == false) {
248		revert LoanEngine__InvalidProof();
249		}
250
251		if (
252	✓ 82.9K	tranchePool.getPoolState() != TranchePool.PoolState.DEPLOYED &&
253	✓ 125.3K	tranchePool.getPoolState() != TranchePool.PoolState.COMMITED
254		) {
255		revert LoanEngine__PoolNotDeployed();
256		}
257
258	✓ 82.9K	if (principalIssued == 0 \|\| aprBps == 0 \|\| termDays == 0) {
259		revert LoanEngine__InvalidLoanParameters(
260		s_nextLoanId,
261		principalIssued,
262		aprBps,
263		termDays
264		);
265		}
266
267	✓ 82.9K	if (originationFeeBps > s_maxOriginationFeeBps) {
268		revert LoanEngine__MaxOriginationFeeExceeded(
269		s_nextLoanId,
270		originationFeeBps,
271		s_maxOriginationFeeBps
272		);
273		}
274
275	✓ 82.9K	if (principalIssued > tranchePool.getTotalIdleValue()) {
276		revert LoanEngine__InsufficientPoolLiquidity();
277		}
278
279	✓ 82.9K	Loan memory newLoan = Loan({
280		loanId: s_nextLoanId,
281		borrowerCommitment: borrowerCommitment,
282		policyVersion: policyVersion,
283		tierId: tierId,
284		principalIssued: principalIssued,
285		principalOutstanding: 0,
286		aprBps: aprBps,
287		originationFeeBps: originationFeeBps,
288		interestAccrued: 0,
289		interestPaid: 0,
290		lastAccrualTimestamp: 0,
291		startTimestamp: 0,
292		maturityTimestamp: 0,
293		termDays: termDays,
294		state: LoanState.CREATED,
295		totalRecovered: 0,
296		seniorPrincipalAllocated: 0,
297		juniorPrincipalAllocated: 0
298		});
299
300		s_loans[s_nextLoanId++] = newLoan;
301		s_nullifierHashes[nullifierHash] = true;
302
303		emit LoanCreated(
304		newLoan.loanId,
305		borrowerCommitment,
306		principalIssued,
307		tierId,
308	✓ 82.9K	block.timestamp
309		);
310		}
311
312		/*
313		preconditions
314		- onlyOwner
315		- loan must already exist
316		- loan.state == CREATED
317		*/
318		function activateLoan(
319		uint256 loanId,
320		address receivingEntity,
321		address feeManager
322		)
323		external
324		onlyOwner
325		isWhiteListedOffRampingEntity(receivingEntity)
326		isWhiteListedFeeManager(feeManager)
327		nonReentrant
328		{
329		// Implementation goes here
330		Loan storage loan = s_loans[loanId];
331
332	✓ 35.3K	if (loan.state != LoanState.CREATED) {
333		revert LoanEngine__LoanIsNotInCreatedState(loanId);
334		}
335	✓ 35.3K	loan.principalOutstanding = loan.principalIssued;
336	✓ 35.3K	loan.lastAccrualTimestamp = block.timestamp;
337	✓ 35.3K	loan.startTimestamp = block.timestamp;
338	✓ 35.3K	loan.maturityTimestamp = block.timestamp + (loan.termDays * 1 days);
339	✓ 35.3K	loan.state = LoanState.ACTIVE;
340
341		uint256 originationFee = (loan.principalIssued *
342	✓ 35.3K	loan.originationFeeBps) / 10000;
343
344		s_originationFees[loanId] = originationFee;
345
346	✓ 35.3K	if (loan.principalIssued > tranchePool.getTotalIdleValue()) {
347		revert LoanEngine__InsufficientPoolLiquidity();
348		}
349
350	✓ 35.3K	uint256 totalDisbursement = loan.principalIssued - originationFee;
351	✓ 35.3K	(uint256 seniorAmount, uint256 juniorAmount, ) = tranchePool
352		.allocateCapital(
353		totalDisbursement,
354		originationFee,
355		receivingEntity,
356		feeManager
357		);
358	✓ 35.3K	loan.seniorPrincipalAllocated = seniorAmount;
359
360	✓ 35.3K	loan.juniorPrincipalAllocated = juniorAmount;
361
362	✓ 35.3K	emit LoanActivated(
363		loan.loanId,
364		loan.principalIssued,
365		block.timestamp,
366		loan.startTimestamp,
367		loan.maturityTimestamp
368		);
369		}
370
371		function repayLoan(
372		uint256 loanId,
373		uint256 principalAmount,
374		uint256 interestAmount,
375		address repaymentAgent
376		)
377		external
378		onlyOwner
379		isWhiteListedRepaymentAgent(repaymentAgent)
380		nonReentrant
381		{
382		Loan storage loan = s_loans[loanId];
383	✓ 17.2K	if (loan.state != LoanState.ACTIVE) {
384		revert LoanEngine__LoanIsNotActive(loanId);
385		}
386
387	✓ 17.2K	uint256 totalPayment = principalAmount + interestAmount;
388	✓ 17.2K	if (totalPayment == 0) {
389		revert LoanEngine__InvalidRepayment();
390		}
391
392	✓ 17.2K	_accrueInterest(loanId);
393
394		// 1️⃣ Transfer funds to pool (settlement layer)
395	✓ 17.2K	IERC20(s_stableCoinAddress).safeTransferFrom(
396		repaymentAgent,
397	✓ 17.2K	address(tranchePool),
398	✓ 17.2K	totalPayment
399		);
400
401		// 2️⃣ Interest first
402	✓ 17.2K	uint256 interestDue = loan.interestAccrued;
403	✓ 17.2K	uint256 interestPaid = totalPayment > interestDue
404		? interestDue
405		: totalPayment;
406
407		// 3️⃣ Principal second
408	✓ 17.2K	uint256 remainingForPrincipal = totalPayment - interestPaid;
409	✓ 17.2K	uint256 principalDue = loan.principalOutstanding;
410
411	✓ 17.2K	uint256 principalPaid = remainingForPrincipal > principalDue
412		? principalDue
413		: remainingForPrincipal;
414
415		// 4️⃣ Update loan accounting
416	✓ 17.2K	loan.interestAccrued -= interestPaid;
417	✓ 17.2K	loan.interestPaid += interestPaid;
418	✓ 17.2K	loan.principalOutstanding -= principalPaid;
419
420	✓ 17.2K	bool fullyRepaid = loan.principalOutstanding == 0 &&
421	✓ 9.5K	loan.interestAccrued == 0;
422
423	✓ 17.2K	if (fullyRepaid) {
424		loan.state = LoanState.REPAID;
425		}
426
427	✓ 17.2K	tranchePool.onRepayment(principalPaid, interestPaid);
428
429		emit LoanRepaid(
430		loan.loanId,
431		principalPaid,
432		interestPaid,
433	✓ 17.2K	block.timestamp
434		);
435
436		if (fullyRepaid) {
437	✓ 9.5K	emit LoanClosed(loanId, block.timestamp);
438		}
439		}
440
441		function declareDefault(
442		uint256 loanId,
443		bytes32 reasonHash
444		) external onlyOwner {
445		// Implementation goes here
446		Loan storage loan = s_loans[loanId];
447	✓ 18	if (loan.state != LoanState.ACTIVE) {
448		revert LoanEngine__LoanIsNotActive(loanId);
449		}
450	✓ 18	_accrueInterest(loanId);
451		loan.state = LoanState.DEFAULTED;
452	✓ 18	emit LoanDefaulted(loanId, reasonHash, block.timestamp);
453		}
454
455		function writeOffLoan(uint256 loanId) external onlyOwner {
456		// Implementation goes here
457		Loan storage loan = s_loans[loanId];
458	✓ 5	if (loan.state != LoanState.DEFAULTED) {
459		revert LoanEngine__LoanIsNotDefaulted(loanId);
460		}
461	✓ 5	uint256 loss = loan.principalOutstanding;
462	✓ 5	uint256 interestAccrued = loan.interestAccrued;
463	✓ 5	if (loss == 0) {
464		revert LoanEngine__ZeroLossOnWriteOff(loanId);
465		}
466
467		loan.principalOutstanding = 0;
468		loan.interestAccrued = 0;
469		loan.state = LoanState.WRITTEN_OFF;
470	✓ 5	tranchePool.onLoss(loss, interestAccrued);
471	✓ 5	emit LoanWrittenOff(loanId, block.timestamp);
472		}
473
474		function recoverLoan(
475		uint256 loanId,
476		uint256 amount,
477		address recoveryAgent
478		) external onlyOwner isWhiteListedRecoveryAgent(recoveryAgent) {
479		Loan storage loan = s_loans[loanId];
480		if (loan.state != LoanState.WRITTEN_OFF) {
481		revert LoanEngine__LoanNotRecoverable(loanId);
482		}
483		if (amount == 0) {
484		revert LoanEngine__ZeroRecovery();
485		}
486		loan.totalRecovered += amount;
487		IERC20(s_stableCoinAddress).safeTransferFrom(
488		recoveryAgent,
489		address(tranchePool),
490		amount
491		);
492		tranchePool.onRecovery(amount);
493		emit LoanRecovered(loanId, amount, block.timestamp);
494		}
495
496		function _accrueInterest(uint256 loanId) internal {
497		// Implementation goes here
498	✓ 17.3K	Loan storage loan = s_loans[loanId];
499	✓ 17.3K	if (loan.state != LoanState.ACTIVE) {
500		revert LoanEngine__LoanIsNotActive(loanId);
501		}
502	✓ 17.3K	uint256 timeElapsed = block.timestamp - loan.lastAccrualTimestamp;
503	✓ 17.3K	if (loan.principalOutstanding == 0) {
504		loan.lastAccrualTimestamp = block.timestamp;
505		return;
506		}
507
508		uint256 interest = (loan.principalOutstanding *
509	✓ 17.3K	loan.aprBps *
510	✓ 17.3K	timeElapsed) / (365 days * 10_000);
511
512	✓ 17.3K	if (interest > 0) {
513	✓ 17.1K	loan.interestAccrued += interest;
514	✓ 17.1K	uint256 totalAllocated = loan.principalIssued;
515		uint256 seniorInterest = (interest *
516	✓ 17.1K	loan.seniorPrincipalAllocated) / totalAllocated;
517
518		uint256 juniorInterest = (interest *
519	✓ 17.1K	loan.juniorPrincipalAllocated) / totalAllocated;
520	✓ 17.1K	tranchePool.onInterestAccrued(
521		interest,
522		seniorInterest,
523		juniorInterest
524		);
525		}
526		loan.lastAccrualTimestamp = block.timestamp;
527		}
528
529		// setters for contract management
530
531		function setMaxOriginationFeeBps(
532		uint256 _maxOriginationFeeBps
533		) external onlyOwner {
534	✓ 1	s_maxOriginationFeeBps = _maxOriginationFeeBps;
535		}
536
537		function setWhitelistedOffRampingEntity(
538		address entity,
539		bool isWhitelisted
540		) external onlyOwner {
541	✓ 1	whitelistedOffRampingEntities[entity] = isWhitelisted;
542		}
543
544		function setWhitelistedRecoveryAgent(
545		address agent,
546		bool isWhitelisted
547		) external onlyOwner {
548	✓ 1	whitelistedRecoveryAgents[agent] = isWhitelisted;
549		}
550
551		function setWhitelistedRepaymentAgent(
552		address agent,
553		bool isWhitelisted
554		) external onlyOwner {
555	✓ 1	whitelistedRepaymentAgents[agent] = isWhitelisted;
556		}
557
558		function setWhitelistedFeeManager(
559		address manager,
560		bool isWhitelisted
561		) external onlyOwner {
562	✓ 1	whitelistedFeeManagers[manager] = isWhitelisted;
563		}
564
565		function getMaxOriginationFeeBps() external view returns (uint256) {
566		return s_maxOriginationFeeBps;
567		}
568
569		function getNextLoanId() external view returns (uint256) {
570	✓ 861.8K	return s_nextLoanId;
571		}
572
573		function getLoanDetails(
574		uint256 loanId
575		) external view returns (Loan memory) {
576		return s_loans[loanId];
577		}
578		}
579

1			// SPDX-License-Identifier: MIT
2			pragma solidity ^0.8.24;
3			import {CreditPolicy} from "../CreditPolicy.sol";
4
5			interface ICreditPolicy {
6			function createPolicy(uint256 version) external;
7
8			function freezePolicy(uint256 version) external;
9
10			function deActivatePolicy(uint256 version) external;
11
12			function updateEligibility(
13			uint256 version,
14			CreditPolicy.EligibilityCriteria calldata data
15			) external;
16
17			function updateRatios(
18			uint256 version,
19			CreditPolicy.FinancialRatios calldata data
20			) external;
21
22			function updateConcentration(
23			uint256 version,
24			CreditPolicy.ConcentrationLimits calldata data
25			) external;
26
27			function updateAttestation(
28			uint256 version,
29			CreditPolicy.AttestationRequirements calldata data
30			) external;
31
32			function updateCovenants(
33			uint256 version,
34			CreditPolicy.MaintenanceCovenants calldata data
35			) external;
36
37			function setLoanTier(
38			uint256 version,
39			uint8 tierId,
40			CreditPolicy.LoanTier calldata tier
41			) external;
42
43			function excludeIndustry(uint256 version, bytes32 industry) external;
44
45			function includeIndustry(uint256 version, bytes32 industry) external;
46
47			function setPolicyDocument(
48			uint256 version,
49			bytes32 hash,
50			string calldata uri
51			) external;
52
53			function tierExistsInPolicy(
54			uint256 version,
55			uint8 tierId
56			) external view returns (bool);
57
58			function changePolicyAdmin(address newAdmin) external;
59
60			function isPolicyActive(uint256 version) external view returns (bool);
61
62			function isPolicyFrozen(uint256 version) external view returns (bool);
63
64			function isIndustryExcluded(
65			uint256 version,
66			bytes32 industry
67			) external view returns (bool);
68			}
69

1			// SPDX-License-Identifier: MIT
2			pragma solidity ^0.8.24;
3			import {TranchePool} from "../TranchePool.sol";
4
5			interface ITranchePool {
6			// logic functions
7
8			function withdrawEquityTrancheByAmount(uint256 amount) external;
9
10			function withdrawJuniorTrancheByAmount(uint256 amount) external;
11
12			function withdrawSeniorTrancheByAmount(uint256 amount) external;
13
14			function withdrawEquityTranche(uint256 shares) external;
15
16			function withdrawJuniorTranche(uint256 shares) external;
17
18			function withdrawSeniorTranche(uint256 shares) external;
19
20			function onInterestAccrued(
21			uint256 interestAmount,
22			uint256 seniorInterest,
23			uint256 juniorInterest
24			) external;
25
26			function onRepayment(
27			uint256 principalRepaid,
28			uint256 interestRepaid
29			) external;
30
31			function onRecovery(uint256 amount) external;
32
33			function allocateCapital(
34			uint256 totalDisbursement,
35			uint256 fees,
36			address deployer,
37			address feeManager
38			)
39			external
40			returns (
41			uint256 seniorAmount,
42			uint256 juniorAmount,
43			uint256 equityAmount
44			);
45
46			function depositEquityTranche(uint256 amount) external;
47
48			function depositJuniorTranche(uint256 amount) external;
49
50			function depositSeniorTranche(uint256 amount) external;
51
52			// updaters
53			function updateEquityTrancheWhiteList(address user, bool status) external;
54
55			function updateWhitelist(address user, bool status) external;
56
57			// setters
58
59			function onLoss(uint256 principalLoss, uint256 interestAccrued) external;
60
61			function setLoanEngine(address _loanEngine) external;
62
63			function setTargetJuniorAPR(uint256 apr) external;
64
65			function setSeniorAPR(uint256 apr) external;
66
67			function setTrancheCapitalAllocationFactorJunior(uint256 factor) external;
68
69			function setTrancheCapitalAllocationFactorSenior(uint256 factor) external;
70
71			function setMinimumDepositAmountEquityTranche(uint256 amount) external;
72
73			function setMinimumDepositAmountSeniorTranche(uint256 amount) external;
74
75			function setMinimumDepositAmountJuniorTranche(uint256 amount) external;
76
77			// getters
78			function getEquityTrancheBalance(
79			address user
80			) external view returns (uint256);
81
82			function getJuniorTrancheBalance(
83			address user
84			) external view returns (uint256);
85
86			function getSeniorTrancheBalance(
87			address user
88			) external view returns (uint256);
89
90			function getPoolState() external view returns (TranchePool.PoolState);
91
92			function getSeniorAllocationRatio() external view returns (uint256);
93
94			function getJuniorAllocationRatio() external view returns (uint256);
95
96			function getTotalIdleValue() external view returns (uint256);
97			}
98

1			// SPDX-License-Identifier: MIT
2			pragma solidity ^0.8.24;
3
4			interface IVerifier {
5			function verify(
6			bytes calldata _proof,
7			bytes32[] calldata _publicInputs
8			) external returns (bool);
9			}
10